Comment dois-je déclarer un tableau de références faibles dans Swift?

Vous pouvez utiliser le NSHashTable avec weakObjectsHashTable. NSHashTable.weakObjectsHashTable()

Pour Swift 3: NSHashTable.weakObjects()

NSHashTable De Référence De Classe

Disponible dans OS X v10.5 et versions ultérieures.

Disponible dans iOS 6.0 et versions ultérieures.

C'est une sorte de fin de partie, mais essayez de la mine. J'ai mis en œuvre comme un Ensemble pas un Tableau.

WeakObjectSet

class WeakObject<T: AnyObject>: Equatable, Hashable {
weak var object: T?
init(object: T) {
self.object = object
}
var hashValue: Int {
if let object = self.object { return unsafeAddressOf(object).hashValue }
else { return 0 }
}
}
func == <T> (lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool {
return lhs.object === rhs.object
}
class WeakObjectSet<T: AnyObject> {
var objects: Set<WeakObject<T>>
init() {
self.objects = Set<WeakObject<T>>([])
}
init(objects: [T]) {
self.objects = Set<WeakObject<T>>(objects.map { WeakObject(object: $0) })
}
var allObjects: [T] {
return objects.flatMap { $0.object }
}
func contains(object: T) -> Bool {
return self.objects.contains(WeakObject(object: object))
}
func addObject(object: T) {
self.objects.unionInPlace([WeakObject(object: object)])
}
func addObjects(objects: [T]) {
self.objects.unionInPlace(objects.map { WeakObject(object: $0) })
}
}

Utilisation

var alice: NSString? = "Alice"
var bob: NSString? = "Bob"
var cathline: NSString? = "Cathline"
var persons = WeakObjectSet<NSString>()
persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObjects([alice!, cathline!])
print(persons.allObjects) //[Alice, Cathline, Bob]

alice = nil
print(persons.allObjects) //[Cathline, Bob]

bob = nil
print(persons.allObjects) // [Cathline]

Attention, WeakObjectSet ne veut pas prendre de type String mais NSString. Parce que, type de Chaîne n'est pas une AnyType. Mon swift version est Apple Swift version 2.2 (swiftlang-703.0.18.1 clang-703.0.29).

Code peut être saisi à partir de Gist.
https://gist.github.com/codelynx/30d3c42a833321f17d39

** AJOUT DE NOV.2017

J'ai mis à jour le code Swift 4

//Swift 4, Xcode Version 9.1 (9B55)

class WeakObject<T: AnyObject>: Equatable, Hashable {
weak var object: T?
init(object: T) {
self.object = object
}
var hashValue: Int {
if var object = object { return UnsafeMutablePointer<T>(&object).hashValue }
return 0
}
static func == (lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool {
return lhs.object === rhs.object
}
}
class WeakObjectSet<T: AnyObject> {
var objects: Set<WeakObject<T>>
init() {
self.objects = Set<WeakObject<T>>([])
}
init(objects: [T]) {
self.objects = Set<WeakObject<T>>(objects.map { WeakObject(object: $0) })
}
var allObjects: [T] {
return objects.flatMap { $0.object }
}
func contains(_ object: T) -> Bool {
return self.objects.contains(WeakObject(object: object))
}
func addObject(_ object: T) {
self.objects.formUnion([WeakObject(object: object)])
}
func addObjects(_ objects: [T]) {
self.objects.formUnion(objects.map { WeakObject(object: $0) })
}
}

Comme gokeji mentionné, j'ai compris NSString ne désallouées basé sur le code de la consommation.
Je me grattais la tête et j'ai écrit MyString classe comme suit.

//typealias MyString = NSString
class MyString: CustomStringConvertible {
var string: String
init(string: String) {
self.string = string
}
deinit {
print("relasing: \(string)")
}
var description: String {
return self.string
}
}

Puis remplacer NSString avec MyString comme ça. Puis, chose étrange à dire, il fonctionne.

var alice: MyString? = MyString(string: "Alice")
var bob: MyString? = MyString(string: "Bob")
var cathline: MyString? = MyString(string: "Cathline")
var persons = WeakObjectSet<MyString>()
persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObjects([alice!, cathline!])
print(persons.allObjects) //[Alice, Cathline, Bob]

alice = nil
print(persons.allObjects) //[Cathline, Bob]

bob = nil
print(persons.allObjects) // [Cathline]

Puis j'ai trouvé une étrange page peut être lié à ce problème.

Référence faible conserve désalloué NSString (XC9 + iOS Sim seulement)

https://bugs.swift.org/browse/SR-5511

Il affirme que le problème est RESOLVED mais je me demande si c'est toujours lié à ce problème.
De toute façon, les différences de Comportement entre MyString ou NSString sont au-delà de ce contexte, mais j'apprécierais si quelqu'un a trouvé cette question.

J'ai eu la même idée pour créer de faibles conteneur avec des génériques.

Comme résultat, j'ai créé wrapper pour NSHashTable:

class WeakSet<ObjectType>: SequenceType {
var count: Int {
return weakStorage.count
}
private let weakStorage = NSHashTable.weakObjectsHashTable()
func addObject(object: ObjectType) {
guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
weakStorage.addObject(object as? AnyObject)
}
func removeObject(object: ObjectType) {
guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
weakStorage.removeObject(object as? AnyObject)
}
func removeAllObjects() {
weakStorage.removeAllObjects()
}
func containsObject(object: ObjectType) -> Bool {
guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
return weakStorage.containsObject(object as? AnyObject)
}
func generate() -> AnyGenerator<ObjectType> {
let enumerator = weakStorage.objectEnumerator()
return anyGenerator {
return enumerator.nextObject() as! ObjectType?
}
}
}

Utilisation:

protocol MyDelegate : AnyObject {
func doWork()
}
class MyClass: AnyObject, MyDelegate {
fun doWork() {
//Do delegated work.
    }
}
var delegates = WeakSet<MyDelegate>()
delegates.addObject(MyClass())
for delegate in delegates {
delegate.doWork()
}

Ce n'est pas la meilleure solution, parce WeakSet peut être initialisée avec n'importe quel type, et si ce type n'est pas conforme à AnyObject protocole de l'app crash détaillée de la raison. Mais je ne vois pas de meilleure solution actuellement.

Solution originale était de définir WeakSet de cette façon:

class WeakSet<ObjectType: AnyObject>: SequenceType {}

Mais dans ce cas WeakSet ne peut pas être initialisé avec le protocole:

protocol MyDelegate : AnyObject {
func doWork()
}
let weakSet = WeakSet<MyDelegate>()

Actuellement de code ci-dessus ne peut pas être compilé (Swift 2.1, Xcode 7.1).

C'est pourquoi j'ai laissé tomber conforme à AnyObject et ajouté des gardes avec fatalError() affirmations.

L'exemple de la WeakContainer est utile, mais cela n'aide pas vraiment une utilisation faible des références dans de swift en récipients tels que les Listes et les Dictionnaires.

Si vous souhaitez utiliser la Liste des méthodes telles que contient, puis le WeakContainer aurez besoin de mettre en œuvre Equatable. J'ai donc ajouté du code pour permettre la WeakContainer être equatable.

Dans le cas où vous voulez utiliser l'WeakContainer dans les dictionnaires, j'ai aussi fait il hashable de sorte qu'il peut être utilisé comme dictionnaire clés.

J'ai aussi renommé WeakObject de souligner que c'est seulement pour les types de classe et de la différencier de la WeakContainer exemples:

struct WeakObject<TYPE where TYPE:AnyObject> : Equatable, Hashable
{
weak var _value : TYPE?
let _originalHashValue : Int
init (value: TYPE)
{
_value = value
//We keep around the original hash value so that we can return it to represent this
        //object even if the value became Nil out from under us because the object went away.
        _originalHashValue = ObjectIdentifier(value).hashValue
}
var value : TYPE?
{
return _value
}
var hashValue: Int
{
return _originalHashValue
}
}
func ==<T>(lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool
{
if lhs.value == nil  &&  rhs.value == nil {
return true
}
else if lhs.value == nil  ||  rhs.value == nil {
return false
}
//If the objects are the same, then we are good to go
    return lhs.value! === rhs.value!
}

Cela vous permet de faire des trucs cool comme utiliser un Dictionnaire de références faibles:

private var m_observerDict : Dictionary<WeakObject<AnyObject>,FLObservationBlock> = Dictionary()
func addObserver( observer:AnyObject, block:FLObservationBlock )
{
let weakObserver = WeakObject(value:observer)
m_observerDict[weakObserver] = block
}
func removeObserver( observer:AnyObject )
{
let weakObserver = WeakObject(value:observer)
m_observerDict.removeValueForKey(weakObserver)
}

Voici comment faire @GoZoner de la grande réponse conforme à Hashable, de sorte qu'il peut être indexé dans le Conteneur d'objets comme: Set, Dictionary, Array, etc.

private class Weak<T: AnyObject>: Hashable {
weak var value : T!
init (value: T) {
self.value = value
}
var hashValue : Int {
//ObjectIdentifier creates a unique hashvalue for objects.
       return ObjectIdentifier(self.value).hashValue
}
}
//Need to override so we can conform to Equitable.
private func == <T>(lhs: Weak<T>, rhs: Weak<T>) -> Bool {
return lhs.hashValue == rhs.hashValue
}

Encore une autre solution pour le même problème... le foyer de celui-ci est sur le stockage à un faible référence à un objet, mais vous permettant de stocker une structure trop.

[Je ne suis pas sûr combien il est utile, mais il a pris un certain temps pour obtenir la syntaxe de droite]

class WeakWrapper : Equatable {
var valueAny : Any?
weak var value : AnyObject?
init(value: Any) {
if let valueObj = value as? AnyObject {
self.value = valueObj
} else {
self.valueAny = value
}
}
func recall() -> Any? {
if let value = value {
return value
} else if let value = valueAny {
return value
}
return nil
}
}
func ==(lhs: WeakWrapper, rhs: WeakWrapper) -> Bool {
return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
}
class Stuff {}
var weakArray : [WeakWrapper] = [WeakWrapper(value: Stuff()), WeakWrapper(value: CGRectZero)]
extension Array where Element : WeakWrapper  {
mutating func removeObject(object: Element) {
if let index = self.indexOf(object) {
self.removeAtIndex(index)
}
}
mutating func compress() {
for obj in self {
if obj.recall() == nil {
self.removeObject(obj)
}
}
}
}
weakArray[0].recall()
weakArray[1].recall() == nil
weakArray.compress()
weakArray.count

Vous pouvez créer un wrapper autour de Array. Ou de l'utilisation de cette bibliothèque https://github.com/NickRybalko/WeakPointerArray

let array = WeakPointerArray<AnyObject>()

Il est de type sécurisé.

Ce ma solution:

• Nettoyer tableau lorsque désalloué, parce que WeakObjectSet de stocker et de ne pas descendre WeakObject
• Résoudre l'erreur fatale lors de l' double élément que l'on trouve dans le Jeu de

--

//MARK: - WeakObjectSet 

public class WeakObject<T: AnyObject>: Equatable, Hashable {
//MARK: Public propreties

public weak var object: T?
public var hashValue: Int {
return self.identifier.hashValue
}
//MARK: Private propreties

private let identifier: ObjectIdentifier
//MARK: Initializer

public init(object: T) {
self.identifier = ObjectIdentifier(object)
self.object = object
}
public static func == (lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool {
return lhs.identifier == rhs.identifier
}
}
//MARK: - WeakObjectSet

public class WeakObjectSet<T: AnyObject> {
//MARK: Public propreties

public var allObjects: [T] {
return allSetObjects.compactMap { $0.object }
}
//MARK: Private propreties

private var objects: Set<WeakObject<T>>
private var allSetObjects: Set<WeakObject<T>> {
get {
objects = self.objects.filter { $0.object != nil }
return objects
}
set {
objects.formUnion(newValue.filter { $0.object != nil })
}
}
//MARK: Initializer

public init() {
self.objects = Set<WeakObject<T>>([])
}
public init(objects: [T]) {
self.objects = Set<WeakObject<T>>(objects.map { WeakObject(object: $0) })
}
//MARK: Public function

public func contains(_ object: T) -> Bool {
return self.allSetObjects.contains(WeakObject(object: object))
}
public func addObject(_ object: T) {
self.allSetObjects.insert(WeakObject(object: object))
}
public func addObjects(_ objects: [T]) {
objects.forEach { self.allSetObjects.insert(WeakObject(object: $0)) }
}
}