Add version check for compound assignment operator traits

Fixes arrayfire#71

Compound operator traits are made stable in Rust 1.8, hence the
version check is required

Author: 9prady9

Cargo.toml

@@ -19,6 +19,7 @@ lazy_static = "0.2.1"
 
 [build-dependencies]
 rustc-serialize = "0.3.16"
+rustc_version = "0.1.7"
 
 [lib]
 name = "arrayfire"

build.rs

@@ -1,5 +1,6 @@
 /* -- Lots of reuse from: https://github.com/alexcrichton/git2-rs/blob/master/libgit2-sys/build.rs */
 extern crate rustc_serialize;
+extern crate rustc_version;
 
 use std::env;
 use std::fs;
@@ -450,4 +451,8 @@ fn main() {
     for backend_dir in backend_dirs.iter() {
         println!("cargo:rustc-link-search=native={}", backend_dir);
     }
+    // Directly check a semver version requirment
+    if rustc_version::version_matches(">= 1.8.0") {
+        println!("cargo:rustc-cfg=op_assign");
+    }
 }

examples/unified.rs

@@ -2,21 +2,32 @@ extern crate arrayfire as af;
 
 use af::*;
 
+#[cfg(op_assign)]
+fn helper(dims: Dim4) {
+  let mut a = randu::<f32>(dims);
+  let b = randu::<f32>(dims);
+  print(&a);
+  print(&b);
+  a += b;
+  print(&a);
+}
+
+#[cfg(not(op_assign))]
+fn helper(dims: Dim4) {
+  let b = randu::<f32>(dims);
+  print(&b);
+}
+
 #[allow(unused_must_use)]
 fn test_backend(){
   info();
 
+  println!("Create a 10-by-10 matrix of random floats on the compute device");
   let num_rows: u64 = 10;
   let num_cols: u64 = 10;
   let dims = Dim4::new(&[num_rows, num_cols, 1, 1]);
 
-  println!("Create a 10-by-10 matrix of random floats on the compute device");
-  let mut a = randu::<f32>(dims);
-  let b = randu::<f32>(dims);
-  print(&a);
-  print(&b);
-  a += b;
-  print(&a);
+  helper(dims)
 }
 
 

src/arith/mod.rs

@@ -8,18 +8,13 @@ use error::HANDLE_ERROR;
 use self::libc::{c_int};
 use data::{constant, tile};
 use self::num::Complex;
-use index::{Indexer, assign_gen};
-use seq::Seq;
-use std::mem;
 
 type MutAfArray = *mut self::libc::c_longlong;
 type MutDouble  = *mut self::libc::c_double;
 type MutUint    = *mut self::libc::c_uint;
 type AfArray    = self::libc::c_longlong;
 
 use std::ops::{Add, Sub, Div, Mul, BitAnd, BitOr, BitXor, Not, Rem, Shl, Shr};
-use std::ops::{AddAssign, SubAssign, DivAssign, MulAssign, BitAndAssign, BitOrAssign, BitXorAssign,
-RemAssign, ShlAssign, ShrAssign};
 
 #[allow(dead_code)]
 extern {
@@ -343,6 +338,18 @@ arith_func!(BitXor, bitxor, af_bitxor);
 arith_func!(Shl, shl, af_bitshiftl);
 arith_func!(Shr, shr, af_bitshiftr);
 
+#[cfg(op_assign)]
+mod op_assign {
+
+use array::Array;
+use super::*;
+use index::{Indexer, assign_gen};
+use seq::Seq;
+use std::mem;
+use std::ops::{AddAssign, SubAssign, DivAssign, MulAssign, RemAssign};
+use std::ops::{BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, ShrAssign};
+
+
 macro_rules! arith_assign_func {
     ($op_name:ident, $fn_name:ident, $func: ident) => (
         impl $op_name<Array> for Array {
@@ -387,3 +394,5 @@ macro_rules! bit_assign_func {
 bit_assign_func!(BitAndAssign, bitand_assign, bitand);
 bit_assign_func!(BitOrAssign, bitor_assign, bitor);
 bit_assign_func!(BitXorAssign, bitxor_assign, bitxor);
+
+}