Fix compilation issue with rustc 1.10.0

After the fix, error module compiles fine with both 1.9.0 and
1.10.0 versions.

Author: 9prady9

src/error.rs

@@ -22,23 +22,48 @@ unsafe impl<'cblifetime> Send for Callback<'cblifetime> {}
 unsafe impl<'cblifetime> Sync for Callback<'cblifetime> {}
 
 
-pub static DEFAULT_HANDLE_ERROR: &'static ErrorCallback = &handle_error_general;
+pub const DEFAULT_HANDLE_ERROR: Callback<'static> = Callback{cb: &handle_error_general};
 
 
 lazy_static! {
     static ref ERROR_HANDLER_LOCK: RwLock< Callback<'static> > =
-        RwLock::new(Callback{cb: DEFAULT_HANDLE_ERROR});
+        RwLock::new(DEFAULT_HANDLE_ERROR);
 }
 
 
+/// Register user provided error handler
+///
+/// # Examples
+/// ```
+/// #[macro_use]
+/// extern crate arrayfire;
+///
+/// use arrayfire::{AfError, Callback, info, register_error_handler};
+/// use std::error::Error;
+///
+/// fn handleError(error_code: AfError) {
+///     match error_code {
+///         AfError::SUCCESS => {}, /* No-op */
+///         _ => panic!("Error message: {}", error_code.description()),
+///     }
+/// }
+///
+/// pub const ERR_HANDLE: Callback<'static> = Callback{ cb: &handleError};
+///
+/// fn main() {
+///     register_error_handler(ERR_HANDLE);
+///
+///     info();
+/// }
+/// ```
 #[allow(unused_must_use)]
-pub fn register_error_handler(cb_value: &'static ErrorCallback) {
+pub fn register_error_handler(cb_value: Callback<'static>) {
     let mut gaurd = match ERROR_HANDLER_LOCK.write() {
         Ok(g) => g,
         Err(_)=> panic!("Failed to acquire lock to register error handler"),
     };
 
-    *gaurd.deref_mut() = Callback{cb:cb_value};
+    *gaurd.deref_mut() = cb_value;
 }
 
 pub fn handle_error_general(error_code: AfError) {

src/lib.rs

@@ -53,7 +53,7 @@ mod defines;
 pub use dim4::Dim4;
 mod dim4;
 
-pub use error::{ErrorCallback, register_error_handler, handle_error_general};
+pub use error::{Callback, ErrorCallback, register_error_handler, handle_error_general};
 mod error;
 
 pub use index::{Indexer, index, row, rows, col, cols, slice, slices,

tests/lib.rs

@@ -25,10 +25,10 @@ implement_handler!(handler_sample2, "Error Handler Sample2");
 implement_handler!(handler_sample3, "Error Handler Sample3");
 implement_handler!(handler_sample4, "Error Handler Sample4");
 
-pub static HANDLE1: &'static ErrorCallback = &handler_sample1;
-pub static HANDLE2: &'static ErrorCallback = &handler_sample2;
-pub static HANDLE3: &'static ErrorCallback = &handler_sample3;
-pub static HANDLE4: &'static ErrorCallback = &handler_sample4;
+pub const HANDLE1: Callback<'static> = Callback{ cb: &handler_sample1};
+pub const HANDLE2: Callback<'static> = Callback{ cb: &handler_sample2};
+pub const HANDLE3: Callback<'static> = Callback{ cb: &handler_sample3};
+pub const HANDLE4: Callback<'static> = Callback{ cb: &handler_sample4};
 
 #[allow(unused_must_use)]
 #[test]
@@ -38,10 +38,10 @@ fn check_error_handler_mutation() {
         thread::Builder::new().name(format!("child {}",i+1).to_string()).spawn(move || {
             println!("{:?}", thread::current());
             match i {
-                0 => register_error_handler(HANDLE1.clone()),
-                1 => register_error_handler(HANDLE2.clone()),
-                2 => register_error_handler(HANDLE3.clone()),
-                3 => register_error_handler(HANDLE4.clone()),
+                0 => register_error_handler(HANDLE1),
+                1 => register_error_handler(HANDLE2),
+                2 => register_error_handler(HANDLE3),
+                3 => register_error_handler(HANDLE4),
                 _ => panic!("Impossible scenario"),
             }
         });