Come gestisco la priorità e la propagazione in un sistema di eventi?

Raccomando le code di priorità in una configurazione produttore / consumatore.

modifica: Ho usato le code di priorità in una sorta di sistema pub / sub prima. Ho creato un oggetto router; un metodo di quell'oggetto era un mittente, con la priorità e il punto di destinazione specificati. C'era un metodo di lettura che sarebbe il punto di destinazione. Sotto il cofano sarebbero le code prioritarie. L'oggetto router gestiva la lettura e la scrittura delle code.

In realtà era un sistema multithread; i produttori di informazioni sarebbero cose come un server http, file, ecc., i consumatori potrebbero essere la coda di eventi di Windows, i file o i messaggi http. Il router gestirà la messaggistica tra produttori e consumatori.

Per il filtraggio, determinerei a chi interessa il filtro e posizionare il blocco del filtro come parte di quell'elemento. Probabilmente ogni elemento (produttore, router e consumatore) otterrebbe la capacità di agganciare. (ad esempio, un elenco di funzioni inoltrate e AND 'd insieme per consentire il passaggio di un messaggio).

Penso che un design a catena sia sufficiente.

Ecco un rapido esempio di ciò che sto cercando di descrivere, in Scala.

object Main extends App {

  // Event 1 - Prints Hello and doesn't break the chain
  val event1 = new Event {
    override def trigger = { println("Hello"); continue }
  }

  // Event 2 - Prints Hello2 but breaks the chain
  val event2 = new Event {
    override def trigger = { println("Hello2"); stop }
  }

  // Create new EventChain
  val eventChain = new EventChain

  // Add event1, then event2 at the beginning
  eventChain.addFirst(event1).addFirst(event2)

  // Bind the event chain to the identifier
  EventManager.bind("my_trigger", eventChain)

  // Trigger a new event
  EventManager.trigger("my_trigger")
}

object EventManager {

  // Keeps track of trigger bindings
  var events = Map[String, EventChain]()

  // Binds a trigger
  def bind(id: String, chain: EventChain) {
    events += ((id, chain))
  }

  // Triggers an EventChain
  def trigger(id: String) {
    events.find(e => e._1 == id) match {
      case Some(event) => event._2.trigger
      case None =>
    }
  }
}

// An event
abstract class Event {
  // Your response here
  def trigger: Boolean;

  // To continue
  def continue = true

  // To break the chain
  def stop = false
}

class EventChain {
  // List of Events
  private var events = List[Event]()

  // Adds an event to the beginning
  def addFirst(event: Event) = {
    events ::= event
    this
  }

  // Triggers the EventChain
  def trigger {

    var continue = true
    val itr = events.iterator

    // While it isn't broken and has another event
    while (continue && itr.hasNext) {
      // Assign the return value to continue
      continue = itr.next.trigger
    }
  }
}

Creerei una classe di tipo pub / sub, che aggregherà tutte le sottoscrizioni, insieme a una priorità, e quindi pubblicherà ciascun evento per priorità, quindi piuttosto che iscriverti all'oggetto stesso, ti iscriveresti al gestore classe

Un collega ha suggerito quanto segue:

object = new Object();
object.bind("my_trigger", function()  { print "hello"; });
object.bind("my_trigger", function()  { print "hello2"; return false; }, { priority : 10 });
object.trigger("my_trigger");

Dopo l'associazione, ordino i miei eventi in base alla priorità e li eseguo in serie fino a quando uno di essi restituisce false e interrompe l'esecuzione.