स्कैला में मानचित्र में कुंजी के रूप में कक्षा का प्रकार

Question

मेरे गेम में

class Enemy 

है जो एआई/कार्यक्षमता है मैं

trait Moving 
trait VerticalMover extends Moving 
trait RandomMover extends Moving 

और अन्य के साथ बदल सकता हूं। अब मुझे विशेषता के आधार पर प्रीलोडेड सामान लाने की जरूरत है। मैं जो करना चाहता हूं वह एक ऐसा नक्शा है जो सभी लक्षणों को स्वीकार करता है जो कि कुंजी के रूप में आगे बढ़ते हैं और फिर कुछ एनीमकंटनर मूल्य के रूप में होते हैं जिसमें विशेषता संबंधित सामग्री प्रीलोड हो जाती है।

लेकिन मैं इस तरह के मानचित्र को कैसे परिभाषित कर सकता हूं और कुछ दुश्मनों के उदाहरण से कंटेनर प्राप्त करने के लिए मेरे .get() को कैसे प्रारूपित करता हूं। कुछ ऐसा:

val myEnemy = new Enemy with RandomMover 
val myDetails:EnemyContainer = enemyDetailsStore.get(myEnemy.getClass) 

Answer 1

ठीक है, मुझे लगता है कि आपके दुश्मन विवरण स्टोर Map[Class[_ <: Moving], EnemyDetails] प्रकार का है। मुझे लगता है कि कुछ की तरह:

//gives a Map[Class[_ <: Moving], EnemyDetails] for all matching keys 
enemyDetailsStore.filterKeys(_ isInstance myEnemy) 

या:

//Iterable[EnemyDetails] 
enemyDetailsStore collect { case (c, d) if c isInstance myEnemy => d } 

या यहां तक ​​कि बस:

//Option[EnemyDetails] 
enemyDetailsStore collectFirst { case (c, d) if c isInstance myEnemy => d } 

आपके लिए क्या करेंगे। इस कोड के साथ एकमात्र "मुद्दा" यह है कि यह ओ (एन) है, जिसमें इसे सरल लुकअप के बजाय मानचित्र के ट्रैवर्सल की आवश्यकता होती है, जो ओ (1), या ओ (लॉग एन)

Answer 2

होगा हो सकता है कि आप एक मैप [मैनिफेस्ट, कोई भी] लपेट सकें ताकि यह सुनिश्चित किया जा सके कि मान मैनिफेस्ट कुंजी से मेल खाते हैं।

कि के संभावित स्केच। सबसे पहले एक छोटे से सहायक

class Typed[A](value: A)(implicit val key: Manifest[A]) { 
    def toPair: (Manifest[_], Any) = (key, value) 
} 
object Typed { 
    implicit def toTyped[A: Manifest](a: A) = new Typed(a) 
    implicit def toTypable[A](a: A) = new { 
    def typedAs[T >: A : Manifest] = new Typed[T](a)(manifest[T]) 
    } 
} 

तो आवरण ही (जो एक नक्शा नहीं है)

class TypedMap private(val inner: Map[Manifest[_], Any]) { 
    def +[A](t: Typed[A]) = new TypedMap(inner + t.toPair) 
    def +[A : Manifest](a: A) = new TypedMap(inner + (manifest[A] -> a)) 
    def -[A : Manifest]() = new TypedMap(inner - manifest[A]) 
    def apply[A : Manifest]: A = inner(manifest[A]).asInstanceOf[A] 
    def get[A : Manifest]: Option[A] = inner.get(manifest[A]).map(_.asInstanceOf[A]) 
    override def toString = inner.toString 
    override def equals(other: Any) = other match { 
    case that: TypedMap => this.inner == that.inner 
    case _ => false 
    } 
    override def hashCode = inner.hashCode 
} 

object TypedMap { 
    val empty = new TypedMap(Map()) 
    def apply(items: Typed[_]*) = new TypedMap(Map(items.map(_.toPair) : _*)) 
} 

इसी के साथ

आप

import Typed._ 
val repository = TypedMap("foo", 12, "bar".typedAs[Any]) 

भंडार कर सकते हैं: TypedMap = मानचित्र (जावा .lang.String -> foo इंट -> 12, किसी भी -> बार)

आप

repository[String] // returns "foo" 
repository.get[Any] // returns Some("bar") 

साथ तत्वों को पुनः प्राप्त मुझे लगता है कि निजी निर्माता सुनिश्चित करना चाहिए कि _ asInstanceOf सुरक्षित है। inner, सार्वजनिक छोड़ा जा सकता है के रूप में यह अपरिवर्तनीय है। इस तरह, Map की समृद्ध इंटरफेस उपलब्ध हो जाएगा, लेकिन दुर्भाग्य से, एक और TypedMap बनाने के लिए नहीं।