Merge pull request maidsafe-archive#21 from ustulation/refactor-types

Refactor types

src/common/name_type.rs

@@ -15,14 +15,20 @@
 
     See the Licences for the specific language governing permissions and limitations relating to
     use of the MaidSafe Software.                                                                 */
+
 extern crate rustc_serialize;
 extern crate sodiumoxide;
 extern crate cbor;
+extern crate rand;
+
 
 use cbor::CborTagEncode;
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use helper::*;
 use std::cmp::*;
+use std::mem;
+use std::fmt;
+use Random;
 
 /// NameType struct
 ///
@@ -38,39 +44,61 @@ use std::cmp::*;
 /// // de-reference id value from the NameType
 /// let maidsafe_types::NameType(id) = name_type;
 /// ```
-#[derive(Eq)]
 pub struct NameType(pub [u8; 64]);
 
-impl PartialEq for NameType {
-  fn eq(&self, other: &NameType) -> bool {
-  	self.0.iter().zip(other.0.iter()).all(|(a,b)| a == b) 
-  }
-  fn ne(&self, other: &NameType) -> bool {
-    !self.0.iter().zip(other.0.iter()).all(|(a,b)| a == b)
-  }
-}
-
-
 impl NameType {
+   #[allow(dead_code)]
+   fn closer_to_target(lhs: &NameType, rhs: &NameType, target: &NameType) -> bool {
+        for i in 0..lhs.0.len() {
+            let res_0 = lhs.0[i] ^ target.0[i];
+            let res_1 = rhs.0[i] ^ target.0[i];
+
+            if res_0 != res_1 {
+                return res_0 < res_1
+            }
+        }
+        false
+    }
 
-  pub fn new(id: [u8;64]) -> NameType {
-    NameType(id)
-  }
+    pub fn new(id: [u8;64]) -> NameType {
+        NameType(id)
+    }
 
-  pub fn get_id(&self) -> [u8;64] {
-    self.0
-  }
-
-  pub fn is_valid(&self) -> bool {
-  	for it in self.0.iter() {
-    if *it != 0 {
-      return true;
+    pub fn get_id(&self) -> [u8;64] {
+        self.0
+    }
+
+    pub fn is_valid(&self) -> bool {
+        for it in self.0.iter() {
+            if *it != 0 {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+impl Random for NameType {
+     fn generate_random() -> NameType {
+        let mut arr: [u8; 64] = unsafe { mem::uninitialized() };
+        for i in 0..64 {
+            arr[i] = rand::random::<u8>();
+        }
+        NameType(arr)
     }
-   }
-   false
-  }
 }
 
+impl fmt::Debug for NameType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self.0.to_vec())
+    }
+}
+
+impl PartialEq for NameType {
+  fn eq(&self, other: &NameType) -> bool {
+  	self.0.iter().zip(other.0.iter()).all(|(a,b)| a == b) 
+  }
+}
 
 impl Clone for NameType {
   fn clone(&self) -> Self {
@@ -101,27 +129,47 @@ impl Decodable for NameType {
   }
 }
 
-#[test]
-fn serialisation_name_type() {
-  let obj_before = NameType([99u8; 64]);
-  let mut e = cbor::Encoder::from_memory();
-  e.encode(&[&obj_before]).unwrap();
+#[cfg(test)]
+mod test {
+    extern crate cbor;
 
-  let mut d = cbor::Decoder::from_bytes(e.as_bytes());
-  let obj_after: NameType = d.decode().next().unwrap().unwrap();
-  assert!(obj_before == obj_after);
-}
+    use Random;
+    use super::*;
 
-#[test]
-fn name_type_equal_assertion() {
-	let type1 = NameType([1u8;64]);
-	let type2 = NameType([1u8;64]);
-	let type3 = NameType([2u8;64]);
-	assert!(type1 == type2);
-	assert!(type1 != type3);
-}
+    #[test]
+    fn serialisation_name_type() {
+      let obj_before = NameType::generate_random();
+      let mut e = cbor::Encoder::from_memory();
+      e.encode(&[&obj_before]).unwrap();
 
-#[test]
-fn name_type_validity_assertion() {
-	assert!(NameType([1u8;64]).is_valid());
+      let mut d = cbor::Decoder::from_bytes(e.as_bytes());
+      let obj_after: NameType = d.decode().next().unwrap().unwrap();
+      assert_eq!(obj_before, obj_after);
+    }
+
+    #[test]
+    fn name_type_equal_assertion() {
+        let type1 = NameType::generate_random();
+        let type1_clone = type1.clone();
+        let type2 = NameType::generate_random();
+        assert_eq!(type1, type1_clone);
+        assert!(type1 == type1_clone);
+        assert!(!(type1 != type1_clone));
+        assert!(type1 != type2);
+    }
+
+    #[test]
+    fn name_type_validity_assertion() {
+        assert!(NameType([1u8;64]).is_valid());
+        assert!(!NameType([0u8; 64]).is_valid());
+    }
+
+    #[test]
+    fn closer_to_target() {
+        let obj0 = NameType::generate_random();
+        let obj0_clone = obj0.clone();
+        let obj1 = NameType::generate_random();
+        assert!(NameType::closer_to_target(&obj0_clone, &obj1, &obj0));
+        assert!(!NameType::closer_to_target(&obj1, &obj0_clone, &obj0));
+    }
 }

src/data/immutable_data.rs

@@ -24,6 +24,9 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use common::NameType;
 use traits::RoutingTrait;
 use sodiumoxide::crypto;
+use std::fmt;
+use rand;
+use Random;
 
 /// ImmutableData
 ///
@@ -37,6 +40,7 @@ use sodiumoxide::crypto;
 /// let ref value = immutable_data.get_value();
 /// ```
 ///
+#[derive(Clone)]
 pub struct ImmutableData {
 	name: NameType,
 	value: Vec<u8>,
@@ -49,12 +53,24 @@ impl RoutingTrait for ImmutableData {
 	}
 }
 
+impl PartialEq for ImmutableData {
+    fn eq(&self, other: &ImmutableData) -> bool {
+        self.name == other.name && self.value == other.value
+    }
+}
+
+impl fmt::Debug for ImmutableData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "ImmutableData( name: {:?}, value: {:?}", self.name, self.value)
+    }
+}
+
 impl ImmutableData {
 	#[allow(dead_code)]
 	pub fn new(name: NameType, value: Vec<u8>) -> ImmutableData {
 		ImmutableData {
-		name: name,
-		value: value,
+    		name: name,
+    		value: value,
 		}
 	}
 
@@ -68,9 +84,23 @@ impl ImmutableData {
 
 }
 
+#[allow(unused_variables)]
+impl Random for ImmutableData {
+    fn generate_random() -> ImmutableData {     
+        let mut data = Vec::with_capacity(64);         
+        for i in 0..data.len() {
+            data.push(rand::random::<u8>());
+        }
+        ImmutableData {            
+            name: NameType::generate_random(),
+            value: data,
+        }
+    }
+}
+
 impl Encodable for ImmutableData {
 	fn encode<E: Encoder>(&self, e: &mut E)->Result<(), E::Error> {
-				CborTagEncode::new(5483_001, &(&self.name, &self.value)).encode(e)
+		CborTagEncode::new(5483_001, &(&self.name, &self.value)).encode(e)
 	}
 }
 
@@ -82,24 +112,33 @@ impl Decodable for ImmutableData {
 	}
 }
 #[cfg(test)]
-mod test {
-use helper::*;
-use super::*;
-use cbor::{ Encoder, Decoder};
-use rustc_serialize::{Decodable, Encodable};
-use common::NameType;
-
-#[test]
-fn serialisation_immutable_data() {
-	let obj_before = ImmutableData::new(NameType([3u8; 64]), vec![99u8; 10]);
-	let mut e = Encoder::from_memory();
-	e.encode(&[&obj_before]).unwrap();
-
-	let mut d = Decoder::from_bytes(e.as_bytes());
-	let obj_after: ImmutableData = d.decode().next().unwrap().unwrap();
-	let id_before = obj_before.get_name().get_id();
-	let id_after = obj_after.get_name().get_id();
-	assert!(compare_u8_array(&id_before, &id_after));
-	assert_eq!(obj_before.get_value(), obj_after.get_value());
-}
+mod test {    
+    use super::*;
+    use cbor::{ Encoder, Decoder};
+    use rustc_serialize::{Decodable, Encodable};
+    use Random;
+
+    #[test]
+    fn serialisation_immutable_data() {
+    	let obj_before = ImmutableData::generate_random();
+    	let mut e = Encoder::from_memory();
+    	e.encode(&[&obj_before]).unwrap();
+
+    	let mut d = Decoder::from_bytes(e.as_bytes());
+    	let obj_after: ImmutableData = d.decode().next().unwrap().unwrap();
+
+    	assert_eq!(obj_before, obj_after);
+    }
+
+    #[test]
+    fn equality_assertion_immutable_data() {
+        let first_obj = ImmutableData::generate_random();
+        let second_obj = ImmutableData::generate_random();
+        let cloned_obj = second_obj.clone();
+
+        assert!(first_obj != second_obj);
+        assert!(second_obj == cloned_obj);    
+    }
+
+
 }

src/data/structured_data.rs

@@ -18,12 +18,14 @@
 extern crate rustc_serialize;
 extern crate sodiumoxide;
 extern crate cbor;
+extern crate rand;
 
 use cbor::CborTagEncode;
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use common::NameType;
 use traits::RoutingTrait;
 use helper::*;
+use Random;
 
 /// StructuredData
 ///
@@ -43,11 +45,31 @@ use helper::*;
 /// let ref value = structured_data.get_value();
 /// ```
 ///
+#[derive(Clone, PartialEq, Debug)]
 pub struct StructuredData {
 	name: (NameType, NameType),  /// name + owner of this StructuredData
 	value: Vec<Vec<NameType>>,
 }
 
+impl Random for StructuredData {
+    fn generate_random() -> StructuredData {
+        let outer_limit = rand::random::<u8>() as usize;
+        let mut outer = Vec::<Vec<NameType>>::with_capacity(outer_limit);
+        for _ in 0..rand::random::<u8>() {
+            let inner_limit = rand::random::<u8>() as usize;
+            let mut inner = Vec::<NameType>::with_capacity(inner_limit);
+            for _ in 0..inner_limit {
+                inner.push(NameType::generate_random());
+            }
+            outer.push(inner);
+        }
+        StructuredData {
+            name: (NameType::generate_random(), NameType::generate_random()),
+            value: outer,
+        }
+    }
+}
+
 impl RoutingTrait for StructuredData {
     fn get_name(&self) -> NameType {
         self.name.0.clone()
@@ -75,7 +97,7 @@ impl StructuredData {
 
 impl Encodable for StructuredData {
 	fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
-				CborTagEncode::new(5483_002, &(&self.name, &self.value)).encode(e)
+		CborTagEncode::new(5483_002, &(&self.name, &self.value)).encode(e)
 	}
 }
 
@@ -89,22 +111,17 @@ impl Decodable for StructuredData {
 
 #[test]
 fn serialisation_structured_data() {
-	let mut value = Vec::new();
-	value.push(Vec::new());
-	match value.last_mut() {
-		Some(v) => v.push(NameType([7u8; 64])),
-		None => ()
-	}
-	let obj_before = StructuredData::new((NameType([3u8; 64]), NameType([5u8; 64])), value);
+	let obj_before = StructuredData::generate_random();
+    let obj_before_clone = obj_before.clone();
+	let obj_before1 = StructuredData::generate_random();
+
 	let mut e = cbor::Encoder::from_memory();
 	e.encode(&[&obj_before]).unwrap();
 
 	let mut d = cbor::Decoder::from_bytes(e.as_bytes());
 	let obj_after: StructuredData = d.decode().next().unwrap().unwrap();
 
-  let name_before = obj_before.get_name();
-  let name_after = obj_after.get_name();
-
-	assert!(name_before.0 == name_after.0);
-	assert!(name_before.1 == name_after.1);
+	assert_eq!(obj_before, obj_after);
+	assert!(!(obj_before != obj_before_clone));
+	assert!(obj_before != obj_before1);
 }