Exemple d'utilisation de la Scala ObservableSet

Question

pourrait Trait quelqu'un me aider à me dire comment utiliser de scala ObservableSetle trait?

Merci beaucoup à l'avance

Answer 1

C'est un peu une horreur avec toutes les informations de frappe, mais c'est ainsi que j'ai pu le faire fonctionner. J'accueille les suggestions sur la façon de rendre le typage plus concis. diverses modifications, y compris les alias de type:

import collection.mutable._ 
import collection.script._ 

val set = new HashSet[String] with ObservableSet[String] { } 

type Msg = Message[String] with Undoable 
type Sub = Subscriber[Msg, ObservableSet[String]] 

val sub = new Sub() { 
    def notify(pub: ObservableSet[String], event: Msg): Unit = { 
    println("%s sent %s".format(pub, event)) 
    event match { 
     case r:Remove[_] => println("undo!"); event.undo() 
     case _ => 
    } 
    } 
} 

set.subscribe(sub) 

set += "foo" 
set += "bar" 
set -= "bar" 

qui imprime:

Set(foo) sent Include(NoLo,foo) 
Set(bar, foo) sent Include(NoLo,bar) 
Set(foo) sent Remove(NoLo,bar) 
undo! 
Set(bar, foo) sent Include(NoLo,bar) 

Fait intéressant, un autre message undo provoqué à publier ...

Answer 2

ObservableSet est un trait qui s'étend du trait Publisher, ce qui donne un comportement de base abonnez-vous publier. Un exemple simple d'utilisation serait:

scala> class Counter(var count: Int) extends Publisher[String] { 
      def inc(): Unit = { 
       count += 1 
       super.publish("updated count to: " + count) 
      } 
    } 

scala> class S[Evt, Pub] extends Subscriber[Evt, Pub] { 
     def notify(pub: Pub, event: Evt): Unit = println("got event: " + event) 
     } 
defined class S 

scala> val s = new S[String, Counter#Pub]  
s: S[String,Counter#Pub] = S@7c27a30c 

scala> val c = new Counter(1) 
c: Counter = Counter@44ba70c 

scala> c.subscribe(s) 

scala> c.inc 
got event: updated count to: 2 

ObservableSet fait quelque chose de similaire, il appelle la méthode publier lorsque des éléments sont ajoutés ou supprimés avec le + = ou + - méthode, voir l'exemple suivant (avec la classe S définie comme ci-dessus):

scala> class MySet extends HashSet[Int] with ObservableSet[Int] {  
    override def +=(elem: Int): this.type = super.+=(elem); 
    override def -=(elem: Int): this.type = super.-=(elem); 
    override def clear: Unit = super.clear;  
} 

defined class MySet 

scala> val set = new MySet 
set: MySet = Set() 

scala> val subS = new S[Any, Any] 
subCol: S[Any,Any] = S@3e898802 

scala> set.subscribe(subS) 

scala> set += 1 
got event: Include(NoLo,1) 
res: set.type = Set(1) 

J'ai beem paresseux en définissant S avec des types Tout, mais je ne pouvais pas le taper immédiatement à droite, et ai passé pas trop longtemps à essayer de comprendre.