scala - Remove on Read

Question

Could anyone suggest an efficient and succinct way of realizing the following feature of "remove on read"? That is, when the attribute _events is read, it's cleared.

case class Event(nanos: Long)

case class History() {
  private val _events = ArrayBuffer[Event]()
  def add(event: Event): Unit = _events += event
  
  def events: List[Event] = {
    val builder = ArrayBuffer[Event]()
    builder ++= _events
    _events.clear()
    builder.toList 
  }
}

Take a look at rxScala (reactive library). https://stackoverflow.com/questions/38900610/rx-how-to-unsubscribe-automatically-after-receiving-onnext — frhack, Aug 03 '20 at 18:35
@frhack I'm new to scala. Can you elaborate on that? Thanks a lot — Max Wong, Aug 03 '20 at 18:39
rx is a framework that implement the observable pattern in many languages. So you can use it in java in javascript or in scala with very similar API — frhack, Aug 03 '20 at 18:42
If you are new to the language this seems to be very advanced and the implementation doesn't look idiomatic. — Luis Miguel Mejía Suárez, Aug 03 '20 at 19:26
@LuisMiguelMejíaSuárez I've written a few lines of codes in scala already. But I still cannot understand the rxScala documentation. — Max Wong, Aug 03 '20 at 19:48

score 3 · Accepted Answer · answered Aug 03 '20 at 18:42

3

Assuming you are not doing concurrency. You don't need to create a new ArrayBuffer. toList creates a new immutable List which will sustain when you clear. Just do

def events: List[Event] = {
  val res = _events.toList
  _events.clear()
  res
}

answered Aug 03 '20 at 18:42

SwiftMango

15,092
13
71
136

Hi I just found that your answer might not be right, res will be empty after `_events.clear()` – Max Wong Aug 03 '20 at 19:55
1

@YanqiHuang it doesn't https://scastie.scala-lang.org/pLD1zrT8SfqiSCUv5UEcZg – SwiftMango Aug 03 '20 at 20:37

score 1 · Answer 2 · answered Aug 04 '20 at 05:12

You can use ConcurrentLinkedQueue of Java. The following solution supports concurrency, in a way that if you add objects, while retrieving the history, they will be added to the history, and to the result of the current call. However, they are read once in this solution. If you need to stop adding while retrieving the history, we can think about a different solution. Consider having the History class as follows:

case class History() {
  private val _events = new ConcurrentLinkedQueue[Event]()
  def add(event: Event): Unit = _events.add(event)

  def events: List[Event] = {
    if (_events.isEmpty) {
      List()
    } else {
      _events.poll() +: events
    }
  }
}

Then, when running the following code:

def main(args: Array[String]): Unit = {
  val h = History()
  List(
    Event(10),
    Event(20),
    Event(30)
  ).foreach(h.add)

  println(s"Events are: ${h.events.mkString(", ")}")
  println(s"Events are: ${h.events.mkString(", ")}")
}

The output is:

Events are: Event(10), Event(20), Event(30)
Events are: 

Process finished with exit code 0

Maybe `_events.toArray(new Event[]).toList` instead of `_events.poll() +: events` would be more performant? — TeWu, Aug 04 '20 at 05:21
I don't think it will be more performant. In both cases we need to access each elment once. The problem with your solution, is that if more elements were added at the time of creating the array, you will remove thenm when removing all elements. And you will never get those when calling the events method. — Tomer Shetah, Aug 04 '20 at 05:24

scala - Remove on Read

2 Answers2