स्विफ्ट कॉम्बिनेशन में बिजनेस लॉजिक को सेव करना। भाग 1

ऑपरेटरों के भंडारण और हस्तांतरण का मिश्रण

कोड करने योग्य संरचना

संख्या की धारा

Just(value).delay(for: .seconds(1), scheduler: DispatchQueue.main)

let val1 = Just(1).delay(for: .seconds(1), scheduler:   DispatchQueue.main)
let val2 = Just(2).delay(for: .seconds(1), scheduler: DispatchQueue.main)
let val3 = ....
let val4 = ....
let publisher = val1.append(val2).append(val3).append(val4)

1. एक धारा एक संरचना में सबसे छोटी इकाई नहीं है। सबसे छोटी धारा का मान है।
2. प्रत्येक स्ट्रीम मान में असीमित ऑपरेटर हो सकते हैं जो नियंत्रित करते हैं कि कब और क्या मूल्य प्रसारित होता है।

अपनी StreamItem बनाएँ

struct StreamItem<T: Codable>: Codable {
 let value: T
 var operators: [Operator]
}

अपना StreamModel बनाएं

struct StreamModel<T: Codable>: Codable, Identifiable {
 var id: UUID
 var name: String?
 var description: String?
 var stream: [StreamItem<T>]
}

एक ऑपरेटर संरचना बनाएँ

enum Operator {
 case delay(seconds: Double)
}

enum Operator {
    case delay(seconds: Double)
}

extension Operator: Codable {

    enum CodingKeys: CodingKey {
        case delay
    }

    struct DelayParameters: Codable {
        let seconds: Double
    }

    enum CodingError: Error { case decoding(String) }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        if let delayParameters = try? container.decodeIfPresent(DelayParameters.self, forKey: .delay) {
            self = .delay(seconds: delayParameters.seconds)
            return
        }
        throw CodingError.decoding("Decoding Failed. \(dump(container))")
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        switch self {
        case .delay(let seconds):
            try container.encode(DelayParameters(seconds: seconds), forKey: .delay)
        }
    }

}

et streamA = (1...4).map { StreamItem(value: $0,
operators: [.delay(seconds: 1)]) }
let serialStreamA = StreamModel(id: UUID(), name: "Serial Stream A",
description: nil, stream: streamA)

ConvertModel को प्रकाशक में बदलें

extension Operator {
func applyPublisher<T>(_ publisher: AnyPublisher<T, Never>) -> AnyPublisher<T, Never> {
  switch self {
    case .delay(let seconds):
    return publisher.delay(for: .seconds(seconds), scheduler: DispatchQueue.main).eraseToAnyPublisher()
  }
 }
}

extension StreamItem {
 func toPublisher() -> AnyPublisher<T, Never> {
   var publisher: AnyPublisher<T, Never> =
                  Just(value).eraseToAnyPublisher()
   self.operators.forEach {
      publisher = $0.applyPublisher(publisher)
   }
  return publisher
}
}

extension StreamModel {
 func toPublisher() -> AnyPublisher<T, Never> {
   let intervalPublishers =
        self.stream.map { $0.toPublisher() }
   var publisher: AnyPublisher<T, Never>?
   for intervalPublisher in intervalPublishers {
     if publisher == nil {
       publisher = intervalPublisher
       continue
     }
     publisher =
        publisher?.append(intervalPublisher).eraseToAnyPublisher()
   }
   return publisher ?? Empty().eraseToAnyPublisher()
 }
}

विज़ुअलाइज़ेशन, संपादन और फिर से एक स्ट्रीम का विज़ुअलाइज़ेशन

अगला अध्याय: सीरियलाइजिंग / डिस्क्रिअलाइजिंग फिल्टर और मैप ऑपरेटर्स