Crea una sottoclasse Swift Dictionary?

Question

Posso creare una sottoclasse di SwiftDictionary in modo che possa passare il mio Dictionary personalizzato a metodi che prevedono un ordinario Dictionary?

Modifica

In my case, I want my custom Dictionary to iterate through its keys in insertion-order.

Answer 1

I dizionari Swift sono strutture, non classi, quindi non possono essere sottoclasse. Idealmente, i metodi con cui si sta lavorando sarebbero dichiarati per prendere un CollectionType generico opportunamente vincolato (o ExtensibleCollectionType, o SequenceType, a seconda della situazione), piuttosto che specificamente un dizionario.

Se ciò non funziona per qualsiasi motivo, è possibile invece creare una sottoclasse di NSDictionary.

(modifica) e, come sottolinea Antonio, è possibile eseguire il dizionario dell'estensione {...} per aggiungere elementi alla struttura del dizionario, che in alcuni casi può sostituire la sottoclasse.

Answer 2

No, dizionari e array a Swift sono le strutture, che non supportano l'ereditarietà. L'unico modo per "personalizzare" un dizionario è usando le estensioni.

Answer 3

Mentre sono d'accordo con la maggior parte dei commenti qui (non è possibile sottoclasse un Struct, in base alla progettazione non è una classe), è possibile ottenere i risultati desiderati con un costume Struct conforme a CollectionType (ora ribattezzato Collection in Swift 3.0):

struct YourCustomDictionary<Key : Hashable, Value>: Collection { 

    private var elements = Dictionary<Key, Value>() 
    private var keyOrder = Array<Key>() 

    //your custom implementation here 
    //including tracking for your dictionary order 

} 

si potrebbe sovraccaricare il metodo indice in modo che aggiunge la chiave per la matrice keyOrder. Quindi fornire un iteratore che restituirà le tuple (Key, Value) nell'ordine corretto.

Probabilmente non è nemmeno necessario conformarsi a Collection, ma questo è un buon modo per ottenere un sacco di funzionalità gratuitamente.

Answer 4

Quanto segue è una struttura conforme alla raccolta che delega a un dizionario. È abbastanza facile da modificare per qualsiasi necessità.

public struct MyDictionary<Key: Hashable, Value: MyKindOfValue>: Collection { 
    public typealias DictionaryType = Dictionary<Key, Value> 
    private var dictionary: DictionaryType 

    //Collection: these are the access methods 
    public typealias IndexDistance = DictionaryType.IndexDistance 
    public typealias Indices = DictionaryType.Indices 
    public typealias Iterator = DictionaryType.Iterator 
    public typealias SubSequence = DictionaryType.SubSequence 

    public var startIndex: Index { return dictionary.startIndex } 
    public var endIndex: DictionaryType.Index { return dictionary.endIndex } 
    public subscript(position: Index) -> Iterator.Element { return dictionary[position] } 
    public subscript(bounds: Range<Index>) -> SubSequence { return dictionary[bounds] } 
    public var indices: Indices { return dictionary.indices } 
    public subscript(key: Key)->Value? { 
     get { return dictionary[key] } 
     set { dictionary[key] = newValue } 
    } 
    public func index(after i: Index) -> Index { 
     return dictionary.index(after: i) 
    } 

    //Sequence: iteration is implemented here 
    public func makeIterator() -> DictionaryIterator<Key, Value> { 
     return dictionary.makeIterator() 
    } 

    //IndexableBase 
    public typealias Index = DictionaryType.Index 
}