Question

I have a class and different equivalence rules on it (different implementation of equals and hashCode). The data is generated in one process first, where one equivalence rule is applied, and then fed to the second process, where the other equivalence rule is applied. Particularly, I am doing a lot of map operations and equals and hashCode are called implicitly by the standard library (which I do not have control on). What do you think is the best way to achieve this? I have two solutions now:

1. Define two subclasses with different equals and hashCode. After process 1, do the conversion by initiating objects of the other subclass.
2. Introduce mutable states in the class to indicate which equivalence rule to apply.

So which one do you think is better or is there any other good solutions?

Answer 1

Finally I find that writing my own customized Map is the way to go (at least in my problem). After I dig into the scala standard library for a while, I figure out that it is extremely easy. No matter whether mutable or not, the element equality and hashCode methods in HashMap are inherited from HashTable and HashTable.Utils and are protected, meaning any subclass can override it easily. So the following is what I end up with:

trait Equility[T] {
  def equal(t1: T, t2: T): Boolean
  def hash(t: T): Int
}

class MapWithEquility[K, V](e: Equility[K]) extends scala.collection.mutable.HashMap[K, V] {
  override def elemHashCode(key: K) = e.hash(key)
  override def elemEquals(key1: K, key2: K) = e.equal(key1, key2)
}

I did a simple test and it worked well.