Merge pull request #152 from csherratt/master

Switch to rustc_serialize

Cargo.toml

@@ -14,5 +14,7 @@ authors = ["Brendan Zabarauskas <bjzaba@yahoo.com.au>",
 ]
 
 [lib]
-
 name = "cgmath"
+
+[dependencies]
+rustc-serialize="*"

src/aabb.rs

@@ -84,7 +84,7 @@ pub trait Aabb<S: BaseNum, V: Vector<S>, P: Point<S, V>> {
 }
 
 /// A two-dimensional AABB, aka a rectangle.
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Aabb2<S> {
     pub min: Point2<S>,
     pub max: Point2<S>,
@@ -129,7 +129,7 @@ impl<S: BaseNum> fmt::Show for Aabb2<S> {
 }
 
 /// A three-dimensional AABB, aka a rectangular prism.
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Aabb3<S> {
     pub min: Point3<S>,
     pub max: Point3<S>,

src/angle.rs

@@ -23,10 +23,10 @@ use approx::ApproxEq;
 use num::{BaseFloat, One, one, Zero, zero};
 
 /// An angle, in radians
-#[deriving(Copy, Clone, PartialEq, PartialOrd, Hash, Encodable, Decodable, Rand)]
+#[deriving(Copy, Clone, PartialEq, PartialOrd, Hash, RustcEncodable, RustcDecodable, Rand)]
 pub struct Rad<S> { pub s: S }
 /// An angle, in degrees
-#[deriving(Copy, Clone, PartialEq, PartialOrd, Hash, Encodable, Decodable, Rand)]
+#[deriving(Copy, Clone, PartialEq, PartialOrd, Hash, RustcEncodable, RustcDecodable, Rand)]
 pub struct Deg<S> { pub s: S }
 
 /// Create a new angle, in radians

src/cgmath.rs

@@ -33,7 +33,7 @@
 //! `look_at`, `from_angle`, `from_euler`, and `from_axis_angle` methods.
 //! These are provided for convenience.
 
-extern crate serialize;
+extern crate "rustc-serialize" as rustc_serialize;
 
 // Re-exports
 

src/cylinder.rs

@@ -18,7 +18,7 @@
 use point::Point3;
 use vector::Vector3;
 
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Cylinder<S> {
     pub center: Point3<S>,
     pub axis: Vector3<S>,

src/frustum.rs

@@ -22,7 +22,7 @@ use plane::Plane;
 use point::Point3;
 use vector::{Vector, EuclideanVector};
 
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Frustum<S> {
     pub left:   Plane<S>,
     pub right:  Plane<S>,
@@ -59,7 +59,7 @@ Frustum<S> {
     }
 }
 
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct FrustumPoints<S> {
     pub near_top_left:     Point3<S>,
     pub near_top_right:    Point3<S>,

src/line.rs

@@ -22,7 +22,7 @@ use ray::{Ray2};
 use intersect::Intersect;
 
 /// A generic directed line segment from `origin` to `dest`.
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Line<P> {
     pub origin: P,
     pub dest: P,

src/matrix.rs

@@ -29,15 +29,15 @@ use vector::{Vector, EuclideanVector};
 use vector::{Vector2, Vector3, Vector4};
 
 /// A 2 x 2, column major matrix
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable, Rand)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
 pub struct Matrix2<S> { pub x: Vector2<S>, pub y: Vector2<S> }
 
 /// A 3 x 3, column major matrix
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable, Rand)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
 pub struct Matrix3<S> { pub x: Vector3<S>, pub y: Vector3<S>, pub z: Vector3<S> }
 
 /// A 4 x 4, column major matrix
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable, Rand)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
 pub struct Matrix4<S> { pub x: Vector4<S>, pub y: Vector4<S>, pub z: Vector4<S>, pub w: Vector4<S> }
 
 

src/obb.rs

@@ -18,14 +18,14 @@
 use point::{Point2, Point3};
 use vector::{Vector2, Vector3};
 
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Obb2<S> {
     pub center: Point2<S>,
     pub axis: Vector2<S>,
     pub extents: Vector2<S>,
 }
 
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Obb3<S> {
     pub center: Point3<S>,
     pub axis: Vector3<S>,

src/plane.rs

@@ -39,7 +39,7 @@ use vector::{Vector, EuclideanVector};
 /// The `A*x + B*y + C*z - D = 0` form is preferred over the other common
 /// alternative, `A*x + B*y + C*z + D = 0`, because it tends to avoid
 /// superfluous negations (see _Real Time Collision Detection_, p. 55).
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Plane<S> {
     pub n: Vector3<S>,
     pub d: S,

src/point.rs

@@ -26,11 +26,11 @@ use num::{BaseNum, BaseFloat, one, zero};
 use vector::*;
 
 /// A point in 2-dimensional space.
-#[deriving(PartialEq, Copy, Clone, Hash, Encodable, Decodable)]
+#[deriving(PartialEq, Copy, Clone, Hash, RustcEncodable, RustcDecodable)]
 pub struct Point2<S> { pub x: S, pub y: S }
 
 /// A point in 3-dimensional space.
-#[deriving(PartialEq, Copy, Clone, Hash, Encodable, Decodable)]
+#[deriving(PartialEq, Copy, Clone, Hash, RustcEncodable, RustcDecodable)]
 pub struct Point3<S> { pub x: S, pub y: S, pub z: S }
 
 

src/projection.rs

@@ -69,7 +69,7 @@ pub trait Projection<S>: ToMatrix4<S> {
 }
 
 /// A perspective projection based on a vertical field-of-view angle.
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct PerspectiveFov<S, A> {
     pub fovy:   A,
     pub aspect: S,
@@ -143,7 +143,7 @@ impl<S: BaseFloat, A: Angle<S>> ToMatrix4<S> for PerspectiveFov<S, A> {
 }
 
 /// A perspective projection with arbitrary left/right/bottom/top distances
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Perspective<S> {
     pub left:   S,  right:  S,
     pub bottom: S,  top:    S,
@@ -193,7 +193,7 @@ impl<S: BaseFloat + 'static> ToMatrix4<S> for Perspective<S> {
 }
 
 /// An orthographic projection with arbitrary left/right/bottom/top distances
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Ortho<S> {
     pub left:   S,  right:  S,
     pub bottom: S,  top:    S,

src/quaternion.rs

@@ -29,7 +29,7 @@ use vector::{Vector3, Vector, EuclideanVector};
 
 /// A [quaternion](https://en.wikipedia.org/wiki/Quaternion) in scalar/vector
 /// form.
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable, Rand)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
 pub struct Quaternion<S> { pub s: S, pub v: Vector3<S> }
 
 /// Represents types which can be expressed as a quaternion.

src/ray.rs

@@ -19,7 +19,7 @@ use vector::{Vector, Vector2, Vector3};
 
 /// A generic ray starting at `origin` and extending infinitely in
 /// `direction`.
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Ray<P,V> {
     pub origin: P,
     pub direction: V,

src/rotation.rs

@@ -161,7 +161,7 @@ pub trait Rotation3<S: BaseNum>: Rotation<S, Vector3<S>, Point3<S>>
 /// let unit_y3 = rot_half.concat(&rot_half).rotate_vector(&unit_x);
 /// assert!(unit_y3.approx_eq(&unit_y2));
 /// ```
-#[deriving(PartialEq, Copy, Clone, Encodable, Decodable)]
+#[deriving(PartialEq, Copy, Clone, RustcEncodable, RustcDecodable)]
 pub struct Basis2<S> {
     mat: Matrix2<S>
 }
@@ -239,7 +239,7 @@ impl<S: BaseFloat + 'static> Rotation2<S> for Basis2<S> {
 /// inversion, can be implemented more efficiently than the implementations for
 /// `math::Matrix3`. To ensure orthogonality is maintained, the operations have
 /// been restricted to a subeset of those implemented on `Matrix3`.
-#[deriving(PartialEq, Copy, Clone, Encodable, Decodable)]
+#[deriving(PartialEq, Copy, Clone, RustcEncodable, RustcDecodable)]
 pub struct Basis3<S> {
     mat: Matrix3<S>
 }

src/sphere.rs

@@ -21,7 +21,7 @@ use point::{Point, Point3};
 use ray::Ray3;
 use vector::Vector;
 
-#[deriving(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[deriving(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
 pub struct Sphere<S> {
     pub center: Point3<S>,
     pub radius: S,

src/transform.rs

@@ -76,7 +76,7 @@ pub trait Transform<S: BaseNum, V: Vector<S>, P: Point<S,V>> {
 
 /// A generic transformation consisting of a rotation,
 /// displacement vector and scale amount.
-#[deriving(Copy, Clone, Encodable, Decodable)]
+#[deriving(Copy, Clone, RustcEncodable, RustcDecodable)]
 pub struct Decomposed<S, V, R> {
     pub scale: S,
     pub rot: R,
@@ -159,7 +159,7 @@ impl<S: BaseFloat, R: fmt::Show + Rotation3<S>> fmt::Show for Decomposed<S,Vecto
 }
 
 /// A homogeneous transformation matrix.
-#[deriving(Copy, Clone, Encodable, Decodable)]
+#[deriving(Copy, Clone, RustcEncodable, RustcDecodable)]
 pub struct AffineMatrix3<S> {
     pub mat: Matrix4<S>,
 }

src/vector.rs

@@ -177,7 +177,7 @@ pub trait Vector<S: BaseNum>: Array1<S> + Zero + One + Neg<Self> {
 // Utility macro for generating associated functions for the vectors
 macro_rules! vec(
     ($Self:ident <$S:ident> { $($field:ident),+ }, $n:expr) => (
-        #[deriving(PartialEq, Eq, Copy, Clone, Hash, Encodable, Decodable, Rand)]
+        #[deriving(PartialEq, Eq, Copy, Clone, Hash, RustcEncodable, RustcDecodable, Rand)]
         pub struct $Self<S> { $(pub $field: S),+ }
 
         impl<$S> $Self<$S> {