hashcode and equals stuff

Author: monkstone

ext/toxi/geom/Line2D.java

@@ -29,7 +29,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 
 import javax.xml.bind.annotation.XmlElement;
 
@@ -205,7 +204,7 @@ public boolean equals(Object obj) {
         }
         return false;
     }
-    
+     
     /**
      * Computes a hash code ignoring the directionality of the line.
      * 
@@ -218,8 +217,7 @@ public boolean equals(Object obj) {
     @Override
     public int hashCode() {
         int hash = 5;
-        hash = 37 * hash + Objects.hashCode(this.a);
-        hash = 37 * hash + Objects.hashCode(this.b);
+        hash = 37 * hash + (a.hashCode() + b.hashCode());
         return hash;
     }
 
@@ -275,10 +273,10 @@ public boolean hasEndPoint(Vec2D p) {
      * @see #hashCode()
      */
     public int hashCodeWithDirection() {
-        long bits = 1L;
-        bits = 31L * bits + a.hashCode();
-        bits = 31L * bits + b.hashCode();
-        return (int) (bits ^ (bits >> 32));
+        int hash = 5;
+        hash = 89 * hash + a.hashCode();
+        hash = 89 * hash + b.hashCode();
+        return hash;
     }
 
     /**

ext/toxi/geom/Line3D.java

@@ -24,15 +24,10 @@
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
-
 package toxi.geom;
-
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
-
 import javax.xml.bind.annotation.XmlElement;
-
 import toxi.geom.Line3D.LineIntersection.Type;
 import toxi.math.MathUtils;
 
@@ -41,6 +36,7 @@ public class Line3D {
     public static class LineIntersection {
 
         public static enum Type {
+
             NON_INTERSECTING,
             INTERSECTING
         }
@@ -56,8 +52,8 @@ private LineIntersection(Type type) {
         private LineIntersection(Type type, Line3D line, float mua, float mub) {
             this.type = type;
             this.line = line;
-            this.coeff = new float[] {
-                    mua, mub
+            this.coeff = new float[]{
+                mua, mub
             };
         }
 
@@ -101,17 +97,12 @@ public String toString() {
      * last segment has a shorter length than the step length requested. The
      * first point (A) can be omitted and not be added to the list if so
      * desired.
-     * 
-     * @param a
-     *            start point
-     * @param b
-     *            end point (always added to results)
-     * @param stepLength
-     *            desired distance between points
-     * @param segments
-     *            existing array list for results (or a new list, if null)
-     * @param addFirst
-     *            false, if A is NOT to be added to results
+     *
+     * @param a start point
+     * @param b end point (always added to results)
+     * @param stepLength desired distance between points
+     * @param segments existing array list for results (or a new list, if null)
+     * @param addFirst false, if A is NOT to be added to results
      * @return list of result vectors
      */
     public static final List<Vec3D> splitIntoSegments(Vec3D a, Vec3D b,
@@ -161,13 +152,14 @@ public Line3D(Vec3D a, Vec3D b) {
      * within the 0.0 .. 1.0 interval the endpoints of the intersection line are
      * within the given line segments, if not then the intersection line is
      * outside.
-     * 
+     *
      * <p>
      * Code based on original by Paul Bourke:<br/>
      * http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline3d/
      * </p>
+     *
      * @param l
-     * @return 
+     * @return
      */
     public LineIntersection closestLineTo(Line3D l) {
         Vec3D p43 = l.a.sub(l.b);
@@ -202,9 +194,8 @@ public LineIntersection closestLineTo(Line3D l) {
 
     /**
      * Computes the closest point on this line to the given one.
-     * 
-     * @param p
-     *            point to check against
+     *
+     * @param p point to check against
      * @return closest point on the line
      */
     public Vec3D closestPointTo(ReadonlyVec3D p) {
@@ -226,31 +217,22 @@ public Line3D copy() {
 
     @Override
     public boolean equals(Object obj) {
-        if (obj == null) {
-            return false;
-        }
-        if (this == obj) {
-            return true;
+        if (obj instanceof Line3D) {
+            Line3D l = (Line3D) obj;
+            return (a.equals(l.a) || a.equals(l.b))
+                    && (b.equals(l.b) || b.equals(l.a));
         }
-        if (!(obj instanceof Line3D)) {
-            return false;
-        }
-        Line3D l = (Line3D) obj;
-        return (a.equals(l.a) || a.equals(l.b))
-                && (b.equals(l.b) || b.equals(l.a));
+        return false;
     }
 
     @Override
     public int hashCode() {
-        int hash = 7;
-        hash = 53 * hash + Objects.hashCode(this.a);
-        hash = 53 * hash + Objects.hashCode(this.b);
-        return hash;
+        return a.hashCode() + b.hashCode();
     }
 
     /**
      * Returns the line's axis-aligned bounding box.
-     * 
+     *
      * @return aabb
      * @see toxi.geom.AABB
      */
@@ -282,22 +264,21 @@ public boolean hasEndPoint(Vec3D p) {
         return a.equals(p) || b.equals(p);
     }
 
-
     /**
      * Computes the hash code for this instance taking directionality into
      * account. A->B will produce a different hash code than B->A. If
      * directionality is not required or desired use the default
      * {@link #hashCode()} method.
-     * 
+     *
      * @return hash code
-     * 
+     *
      * @see #hashCode()
      */
     public int hashCodeWithDirection() {
-        long bits = 1L;
-        bits = 31L * bits + a.hashCode();
-        bits = 31L * bits + b.hashCode();
-        return (int) (bits ^ (bits >> 32));
+        int hash = 7;
+        hash = 53 * hash + a.hashCode();
+        hash = 53 * hash + b.hashCode();
+        return hash;
     }
 
     public Line3D offsetAndGrowBy(float offset, float scale, Vec3D ref) {

ext/toxi/geom/Vec2D.java

@@ -1146,4 +1146,4 @@ public final float x() {
     public final float y() {
         return y;
     }
-}
+}

ext/toxi/geom/Vec3D.java

@@ -1653,4 +1653,4 @@ public final float y() {
     public final float z() {
         return z;
     }
-}
+}

ext/toxi/geom/Vec4D.java

@@ -149,17 +149,9 @@ public final float angleBetween(ReadonlyVec4D v) {
         return (float) (Math.acos(vDot));
     }
 
-//    public Object clone() {
-//        try {
-//            return super.clone();
-//        } catch (CloneNotSupportedException e) {
-//            throw new InternalError();
-//        }
-//    }
-
     @Override
     public int compareTo(ReadonlyVec4D v) {
-        if (x == v.x() && y == v.y() && z == v.z() && w == v.w()) {
+        if (this.equals(v)) {
             return 0;
         }
         float a = magSquared();
@@ -218,7 +210,16 @@ public final float dot(ReadonlyVec4D v) {
     public boolean equals(Object v) {
         if (v instanceof ReadonlyVec4D) {
             ReadonlyVec4D vv = (ReadonlyVec4D) v;
-            return (x == vv.x() && y == vv.y() && z == vv.z() && w == vv.w());
+            if (!((Float) x).equals(vv.x())) {
+                return false;
+            }
+            if (!((Float) y).equals(vv.y())) {
+                return false;
+            }
+            if (!((Float) z).equals(vv.z())) {
+                return false;
+            }
+            return ((Float) w).equals(vv.w());
         }
         return false;
     }
@@ -252,16 +253,21 @@ public int hashCode() {
      * @return true or false
      */
     public boolean equals(ReadonlyVec4D v) {
-        try {
-            return (x == v.x() && y == v.y() && z == v.z() && w == v.w());
-        } catch (NullPointerException e) {
-            return false;
-        }
+        if (!((Float) x).equals(v.x())) {
+                return false;
+            }
+            if (!((Float) y).equals(v.y())) {
+                return false;
+            }
+            if (!((Float) z).equals(v.z())) {
+                return false;
+            }
+            return ((Float) w).equals(v.w());
     }
 
     @Override
     public boolean equalsWithTolerance(ReadonlyVec4D v, float tolerance) {
-        try {
+        if (v instanceof ReadonlyVec4D) {
             float diff = x - v.x();
             if (Float.isNaN(diff)) {
                 return false;
@@ -288,9 +294,8 @@ public boolean equalsWithTolerance(ReadonlyVec4D v, float tolerance) {
                 return false;
             }
             return ((diff > 0 ? -diff : diff) < tolerance);
-        } catch (NullPointerException e) {
-            return false;
         }
+        return false;
     }
 
     @Override