Протокол, соответствующий Equatable для Diffing - PullRequest
Новая
       92

Протокол, соответствующий Equatable для Diffing

0 голосов
/ 27 октября 2019

У меня есть небольшое приложение чата.

У меня может быть два типа сообщений: - текст - видео

Я использую полиморфизм при декодировании JSON следующим образом: 

import Foundation

enum MessageType: Int, Decodable {
    case text
    case video
}

protocol Message: Decodable {
    static var type: MessageType { get }
    var id: String { get }
    var user: User { get}
    var timestamp: String { get }
}

struct TextMessage: Message {
    static var type: MessageType = .text
    var id: String
    var user: User
    var timestamp: String
    let text: String
}

struct VideoMessage: Message {
    static var type: MessageType = .video
    var id: String
    var user: User
    var timestamp: String
    let text: String
    let link: String
    let poster: String
}

enum MessageWrapper: Decodable {

    enum CodingKeys: String, CodingKey {
        case type
    }

    case text(TextMessage)
    case video(VideoMessage)

    var item: Message {
        switch self {
        case .text(let item): return item
        case .video(let item): return item
        }
    }

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        let type = try values.decode(Int.self, forKey: .type)
        switch type {
        case MessageType.text.rawValue: self = .text(try TextMessage(from: decoder))
        case MessageType.video.rawValue: self = .video(try VideoMessage(from: decoder))
        default:
            throw DecodingError.dataCorruptedError(forKey: .type,
                                                   in: values,
                                                   debugDescription: "Invalid type")
        }
    }
}

Я также использую подход MVVM следующим образом: 

struct ChatViewModel {

    enum ViewModelType {
        case loading
        case text(TextMessageViewModel)
        case video(VideoMessageViewModel)
        case failure(ErrorViewModel)
    }

    enum State {
        case initialized
        case loading
        case loaded([Message])
        case failed(Error)
    }

    let state: State
    let viewModels: [ViewModelType]

    init(with state: State) {
        self.state = state
        switch state {
        case .initialized:
            viewModels = []
        case .loading:
            viewModels = [
                .loading,
            ]
        ......
    }
}

Чтобы иметь возможность использовать библиотеку Diffing, например Differ , ChatViewModel долженсоответствует протоколу Equatable. 

extension ChatViewModel: Equatable {
    static func == (lhs: ChatViewModel, rhs: ChatViewModel) -> Bool {
        return lhs.state == rhs.state
    }
}

extension ChatViewModel.State: Equatable {
    static func == (lhs: ChatViewModel.State, rhs: ChatViewModel.State) -> Bool {
        switch (lhs, rhs) {
            case (.initialized, .initialized): return true
            case (.loading, .loading): return true
            case let (.loaded(l), .loaded(r)): return l == r
            case let (.failed(l), .failed(r)): return l.localizedDescription == r.localizedDescription
            default: return false
        }
    }
}

Проблема здесь в том, что case let (.loaded(l), .loaded(r)): return l == r, Message, как протокол, не соответствует Equatable.

Приведение его в соответствие Equatable, как 

protocol Message: Decodable, Equatable {
    static var type: MessageType { get }
    var id: String { get }
    var user: User { get}
    var timestamp: String { get }
}

, приводит к ошибке Protocol 'Message' can only be used as a generic constraint because it has Self or associated type requirements для MessageWrapper: 

enum MessageWrapper: Decodable {

    ...

    var item: Message { // Protocol 'Message' can only be used as a generic constraint because it has Self or associated type requirements
        switch self {
        case .text(let item): return item
        case .video(let item): return item
        }
    }

    ...
}

Любая идея или предложение, чтобы иметь чистый способ решить эту проблему? Я видел сообщение о Type Erasure, но после некоторых тестов я не уверен, что оно действительно решает проблему.

1 Ответ

0 голосов
/ 27 октября 2019

Вам не нужно соответствовать Equatable, чтобы иметь возможность использовать оператор ==. Вы можете просто определить такой оператор самостоятельно, без соответствия Equatable.

. Для удобства я предположу, что TextMessage и VideoMessage уже соответствуют Equatable.

*. 1010 * Сначала напишите метод, который сравнивает Message s: 
func messageEqual(m1: Message, m2: Message) -> Bool {
    if let textMessage1 = m1 as? TextMessage, let textMessage2 = m2 as? TextMessage {
        return textMessage1 == textMessage2
    }
    if let videoMessage1 = m1 as? VideoMessage, let videoMessage2 = m2 as? VideoMessage {
        return videoMessage1 == videoMessage2
    }
    return false
}

Тогда оператор == для [Message]: 

func ==(messages1: [Message], messages2: [Message]) -> Bool {
    return messages1.count == messages2.count && 
        zip(messages1, messages2).allSatisfy(messageEqual)
}

Теперь l == r должен скомпилироваться.

...