From cec0389a8a30276a70b13b47f8f5a9722982f73b Mon Sep 17 00:00:00 2001
From: Evgeny Gerashchenko <Evgeny.Gerashchenko@jetbrains.com>
Date: Thu, 24 Jan 2013 01:49:47 +0400
Subject: [PATCH] Added equals, hashCode and toString to sequences.

---
 runtime/src/jet/ByteSequence.java      | 32 ++++++++++++++++++++++
 runtime/src/jet/CharacterSequence.java | 32 ++++++++++++++++++++++
 runtime/src/jet/DoubleSequence.java    | 37 ++++++++++++++++++++++++++
 runtime/src/jet/FloatSequence.java     | 32 ++++++++++++++++++++++
 runtime/src/jet/IntSequence.java       | 32 ++++++++++++++++++++++
 runtime/src/jet/LongSequence.java      | 32 ++++++++++++++++++++++
 runtime/src/jet/ShortSequence.java     | 32 ++++++++++++++++++++++
 7 files changed, 229 insertions(+)

diff --git a/runtime/src/jet/ByteSequence.java b/runtime/src/jet/ByteSequence.java
index f678ee74dbc..e545e8faab1 100644
--- a/runtime/src/jet/ByteSequence.java
+++ b/runtime/src/jet/ByteSequence.java
@@ -52,4 +52,36 @@ public class ByteSequence implements NumberSequence<Byte> {
     public ByteIterator iterator() {
         return new ByteSequenceIterator(start, end, increment);
     }
+
+    @Override
+    public String toString() {
+        if (increment > 0) {
+            return start + ".." + end + " step " + increment;
+        }
+        else {
+            return start + " downTo " + end + " step " + -increment;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        ByteSequence bytes = (ByteSequence) o;
+
+        if (end != bytes.end) return false;
+        if (increment != bytes.increment) return false;
+        if (start != bytes.start) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (int) start;
+        result = 31 * result + (int) end;
+        result = 31 * result + increment;
+        return result;
+    }
 }
diff --git a/runtime/src/jet/CharacterSequence.java b/runtime/src/jet/CharacterSequence.java
index 65ad0e07f5f..afebd919fdb 100644
--- a/runtime/src/jet/CharacterSequence.java
+++ b/runtime/src/jet/CharacterSequence.java
@@ -52,4 +52,36 @@ public class CharacterSequence implements NumberSequence<Character> {
     public CharIterator iterator() {
         return new CharacterSequenceIterator(start, end, increment);
     }
+
+    @Override
+    public String toString() {
+        if (increment > 0) {
+            return start + ".." + end + " step " + increment;
+        }
+        else {
+            return start + " downTo " + end + " step " + -increment;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        CharacterSequence that = (CharacterSequence) o;
+
+        if (end != that.end) return false;
+        if (increment != that.increment) return false;
+        if (start != that.start) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (int) start;
+        result = 31 * result + (int) end;
+        result = 31 * result + increment;
+        return result;
+    }
 }
diff --git a/runtime/src/jet/DoubleSequence.java b/runtime/src/jet/DoubleSequence.java
index 24a2aa35397..03fa81574ff 100644
--- a/runtime/src/jet/DoubleSequence.java
+++ b/runtime/src/jet/DoubleSequence.java
@@ -52,4 +52,41 @@ public class DoubleSequence implements NumberSequence<Double> {
     public DoubleIterator iterator() {
         return new DoubleSequenceIterator(start, end, increment);
     }
+
+    @Override
+    public String toString() {
+        if (increment > 0) {
+            return start + ".." + end + " step " + increment;
+        }
+        else {
+            return start + " downTo " + end + " step " + -increment;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        DoubleSequence doubles = (DoubleSequence) o;
+
+        if (Double.compare(doubles.end, end) != 0) return false;
+        if (Double.compare(doubles.increment, increment) != 0) return false;
+        if (Double.compare(doubles.start, start) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result;
+        long temp;
+        temp = start != +0.0d ? Double.doubleToLongBits(start) : 0L;
+        result = (int) (temp ^ (temp >>> 32));
+        temp = end != +0.0d ? Double.doubleToLongBits(end) : 0L;
+        result = 31 * result + (int) (temp ^ (temp >>> 32));
+        temp = increment != +0.0d ? Double.doubleToLongBits(increment) : 0L;
+        result = 31 * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
 }
diff --git a/runtime/src/jet/FloatSequence.java b/runtime/src/jet/FloatSequence.java
index 26224e9a462..f5dd8d4639b 100644
--- a/runtime/src/jet/FloatSequence.java
+++ b/runtime/src/jet/FloatSequence.java
@@ -52,4 +52,36 @@ public class FloatSequence implements NumberSequence<Float> {
     public FloatIterator iterator() {
         return new FloatSequenceIterator(start, end, increment);
     }
+
+    @Override
+    public String toString() {
+        if (increment > 0) {
+            return start + ".." + end + " step " + increment;
+        }
+        else {
+            return start + " downTo " + end + " step " + -increment;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        FloatSequence floats = (FloatSequence) o;
+
+        if (Float.compare(floats.end, end) != 0) return false;
+        if (Float.compare(floats.increment, increment) != 0) return false;
+        if (Float.compare(floats.start, start) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (start != +0.0f ? Float.floatToIntBits(start) : 0);
+        result = 31 * result + (end != +0.0f ? Float.floatToIntBits(end) : 0);
+        result = 31 * result + (increment != +0.0f ? Float.floatToIntBits(increment) : 0);
+        return result;
+    }
 }
diff --git a/runtime/src/jet/IntSequence.java b/runtime/src/jet/IntSequence.java
index e15a37c480b..88e06657e91 100644
--- a/runtime/src/jet/IntSequence.java
+++ b/runtime/src/jet/IntSequence.java
@@ -52,4 +52,36 @@ public class IntSequence implements NumberSequence<Integer> {
     public IntIterator iterator() {
         return new IntSequenceIterator(start, end, increment);
     }
+
+    @Override
+    public String toString() {
+        if (increment > 0) {
+            return start + ".." + end + " step " + increment;
+        }
+        else {
+            return start + " downTo " + end + " step " + -increment;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        IntSequence sequence = (IntSequence) o;
+
+        if (end != sequence.end) return false;
+        if (increment != sequence.increment) return false;
+        if (start != sequence.start) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = start;
+        result = 31 * result + end;
+        result = 31 * result + increment;
+        return result;
+    }
 }
diff --git a/runtime/src/jet/LongSequence.java b/runtime/src/jet/LongSequence.java
index 4972d588ca0..217884fe624 100644
--- a/runtime/src/jet/LongSequence.java
+++ b/runtime/src/jet/LongSequence.java
@@ -52,4 +52,36 @@ public class LongSequence implements NumberSequence<Long> {
     public LongIterator iterator() {
         return new LongSequenceIterator(start, end, increment);
     }
+
+    @Override
+    public String toString() {
+        if (increment > 0) {
+            return start + ".." + end + " step " + increment;
+        }
+        else {
+            return start + " downTo " + end + " step " + -increment;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        LongSequence longs = (LongSequence) o;
+
+        if (end != longs.end) return false;
+        if (increment != longs.increment) return false;
+        if (start != longs.start) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (int) (start ^ (start >>> 32));
+        result = 31 * result + (int) (end ^ (end >>> 32));
+        result = 31 * result + (int) (increment ^ (increment >>> 32));
+        return result;
+    }
 }
diff --git a/runtime/src/jet/ShortSequence.java b/runtime/src/jet/ShortSequence.java
index e2cac38b247..30b3e79a382 100644
--- a/runtime/src/jet/ShortSequence.java
+++ b/runtime/src/jet/ShortSequence.java
@@ -52,4 +52,36 @@ public class ShortSequence implements NumberSequence<Short> {
     public ShortIterator iterator() {
         return new ShortSequenceIterator(start, end, increment);
     }
+
+    @Override
+    public String toString() {
+        if (increment > 0) {
+            return start + ".." + end + " step " + increment;
+        }
+        else {
+            return start + " downTo " + end + " step " + -increment;
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        ShortSequence shorts = (ShortSequence) o;
+
+        if (end != shorts.end) return false;
+        if (increment != shorts.increment) return false;
+        if (start != shorts.start) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (int) start;
+        result = 31 * result + (int) end;
+        result = 31 * result + increment;
+        return result;
+    }
 }