How to implement class that supports circular iteration and deletion - scala

Question

I have a class, that should support circular iteration and deletion:
class CircularTest {
private val set = mutable.LinkedHashSet[String]("1", "2", "3", "4", "5")
private val circularIter: Iterator[String] = Iterator.continually(set).flatten
def selectNext: String = {
circularIter.next()
}
def remove(v: String): Unit = {
set.remove(v)
}
}
And this not working.
Simple test, that should work:
val circularTest = new CircularTest
circularTest.selectNext shouldEqual "1"
circularTest.selectNext shouldEqual "2"
circularTest.remove("3")
circularTest.remove("5")
circularTest.selectNext shouldEqual "4" // actual "3"
circularTest.selectNext shouldEqual "1"
How to implement this functionality? Or maybe other solution with no iterator?

Answer 1

Well... The thing is that the Iterator.continually will give you a kind of immutable thing in this case. Which means that even if you change the content of your set it will have no effect on iterator.
You can actually have a work around that with updating the iterator itself in the remove method.
class CircularTest {
private var set = Set[String]("1", "2", "3", "4", "5")
private var circularIter: Iterator[String] = Iterator.continually(set).flatten
def selectNext: String = this.synchronized {
circularIter.next()
}
def remove(v: String): Unit = this.synchronized {
set = set.remove(v)
circularIter = Iterator.continually(set).flatten
}
}
But a better approach is to actually implement your own iterator in proper way.
import scala.collection.immutable.HashSet
import scala.collection.mutable.ArrayBuffer
class MyCircularIterator[T] extends Iterator[T] {
private var index: Int = 0
private var set: mutable.LinkedHashSet[T] = mutable.LinkedHashSet()
private var vector: Vector[T] = Vector()
private var vectorSize: Int = 0
override def hasNext: Boolean = this.synchronized {
set.size match {
case 0 => false
case _ => true
}
}
// Iterator does not define `next()` behavior whe hasNext == false;
// here it will just throw IndexOutOfBoundsException
override def next(): T = this.synchronized {
index = index % vectorSize
val next = vector(index)
index = index + 1
next
}
def add(t: T*): Unit = this.synchronized {
set = set ++ t
vector = Vector(set.toList: _*)
vectorSize = vector.length
}
def remove(t: T*): Unit = this.synchronized {
set = set -- t
vector = Vector(set.toList: _*)
vectorSize = vector.length
}
}
object MyCircularIterator {
def apply[T](hashSet: HashSet[T]): MyCircularIterator[T] = {
val iter = new MyCircularIterator[T]()
iter.add(hashSet.toList: _*)
iter
}
}
Now you can use it like this,
val myCircularIterator = MyCircularIterator(HashSet[Int](1, 2, 3, 4, 5))
myCircularIterator.next()
// 1
myCircularIterator.next()
// 2
myCircularIterator.remove(3, 5)
myCircularIterator.next()
// 4
myCircularIterator.next()
// 1