Feature/eventemitters

[RLesur]

In this PR, we introduce the EventEmitter class. This class is inspired from the node.js EventEmitter class as mentioned in #8

[cderv]

Out of curiosity, why the need of once_function ? For adding a specific class to fun ?
I thought removing the listener was a guaranty of running it once. 🤔

[RLesur]

I've played a lot in node.js with the events module. I wanted to understand some behaviors.
More precisely, when I ran those examples, I realized that rawListeners just run once. This was not the case with our current implementation.
In node.js, rawListeners are listeners wrapped in a once wrapper object.

[cderv]

Nice additions ! Tell me when you are ready.

FWIW, I planned to add the complete https://nodejs.org/api/events.html spec if event emitter was interesting to us. I currently just use what was interesting for crrri. I would have wait for #29 for a complete R API.

[RLesur]

I am not ready yet. I wanted to be sure that we were in the right direction. After carefuly reading the specs, I have a serious doubt.
I think that with the Callbacks class of rstudio/websocket, we will struggle to implement the prependListener and prependOnceListener methods.
Now, I'm convinced that at one time, we will have to implement a custom class for dealing with that and remove the code from rstudio/websocket.
So, I wonder whether it is worth to integrate now these code from rstudio/websocket and change the License.
I have an idea of implementation for another class that would support a prepend method.
I would prefer to test this idea before merging this PR, change the License, and so on...

[cderv]

Ok I see. You went further than I expected. ☺️

Initially, I work on this to provide the necessary base for creating CDPSession in order to have a working POC to decide if this API was useful. I did not put all energy to make a complete and thorough rewrite of event emitter class.

As you want to go deeper, I believe you find it useful 😄

Rewriting this sounds like a good idea. I also have other ideas as I limit myself in the first round. It could be cleaner to rewrite in another branch maybe. (not sure 🤔 )

Are you planning on going further on this before looking to the upper layer (CDPSession) to have the bigger picture ?

[RLesur]

I will give my idea a try during traveling tonight (2 hours, sounds like a good timeout for a try). I let you know after that.

[RLesur]

I like working in the 🚄 (except for the connexion).
The problem of {websocket} Callbacks class is that it does not handle well a queue (we cannot prepend an element).
So, here's a proposal of an R6 class Queue.
The main difference is that Queue is generic (it handle any object): so, there is no invoke methods (not a problem for me). Otherwise, it has a similar behavior. The main advance is that with Queue, we can prepend an element:

Queue <- R6::R6Class(
  "Queue",
  private = list(
    .queue = list(),
    .wrap = function(element) {
      wrapper <- new.env(parent = emptyenv(), size = 1L)
      wrapper$element <- element
      wrapper
    },
    .rm_wrapper = function(wrapper) {
      element <- wrapper$element
      queue <- private$.queue
      # Since wrappers are environments, identical() will always send back at most one element.
      # This is the main trick.
      pos <- Position(function(x) identical(x, wrapper), queue)
      queue[pos] <- NULL
      private$.queue <- queue
      element
    }
  ),
  public = list(
    append = function(element) {
      wrapper <- private$.wrap(element)
      private$.queue <- c(private$.queue, list(wrapper))
      function() {private$.rm_wrapper(wrapper)}
    },
    prepend = function(element) {
      wrapper <- private$.wrap(element)
      private$.queue <- c(list(wrapper), private$.queue)
      function() {private$.rm_wrapper(wrapper)}
    },
    get = function() {
      lapply(private$.queue, function(w) get("element", pos = w))
    },
    remove_element = function(element, right = TRUE) {
      queue <- private$.queue
      pos <- Position(function(x) identical(x$element, element), queue, right = right)
      queue[pos] <- NULL
      private$.queue <- queue
      element
    }
  )
)

My idea is to use Queue instead of Callbacks. The invoke code would be moved inside EventEmitter$emit() method.
What do you think of that?
If we don't use Callbacks, all the code will be from us and there would be no need to change the License.

[cderv]

It is merged ! Thanks! I hope my previous work help you for the rewrite ! 😉
Good implementation !
Let's continue with CDP session now.