11Feature/canle charts

DXFeedFramework/Api/Osub/IndexedEventSubscriptionSymbol.swift

@@ -64,10 +64,16 @@ public class IndexedEventSubscriptionSymbol: Symbol {
 
     /// Custom symbol has to return string representation.
     public var stringValue: String {
-        return "\(symbol.stringValue)source=\(source.toString())"
+        return "\(symbol.stringValue){source=\(source.toString())}"
     }
 }
 
+extension IndexedEventSubscriptionSymbol: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.symbol.stringValue)
+        hasher.combine(self.source.toString())
+    }
+}
 extension IndexedEventSubscriptionSymbol: Equatable {
     public static func == (lhs: IndexedEventSubscriptionSymbol,
                            rhs: IndexedEventSubscriptionSymbol) -> Bool {

DXFeedFramework/Events/Market/Extra/OrderBase.swift

@@ -311,3 +311,20 @@ extension OrderBase {
         }
     }
 }
+
+public extension OrderBase {
+    /// Returns true if this order has some size (sizeAsDouble is neither 0 nor NaN).
+    func hasSize() -> Bool {
+        return size != 0 && !size.isNaN
+    }
+}
+
+extension OrderBase: Hashable {
+    public static func == (lhs: OrderBase, rhs: OrderBase) -> Bool {
+        return lhs.index == rhs.index
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.index)
+    }
+}

DXFeedFramework/Events/Market/Extra/OrderSource.swift

@@ -45,7 +45,7 @@ public class OrderSource: IndexedEventSource {
     /// It is a synthetic source.
     /// The subscription on composite ``Quote`` event is observed when this source is subscribed to.
     public static let compsoiteBid =
-    try? OrderSource(1, "COMPOSITE_BID", pubOrder | pubAnalyticOrder | pubSpreadOrder | fullOrderBook)
+    try? OrderSource(1, "COMPOSITE_BID", 0)
     /// Ask side of a composite ``Quote``.
     /// It is a synthetic source.
     /// The subscription on composite ``Quote`` event is observed when this source is subscribed to.
@@ -95,12 +95,18 @@ public class OrderSource: IndexedEventSource {
     /// Direct-Edge EDGX Exchange.
     public static let DEX = try? OrderSource("DEX", pubOrder)
 
+    /// Direct-Edge EDGX Exchange. Record for price level book.
+    public static let dex = try? OrderSource("dex", pubOrder)
+
     /// Bats BYX Exchange.
     public static let BYX = try? OrderSource("BYX", pubOrder)
 
     /// Bats BZX Exchange.
     public static let BZX = try? OrderSource("BZX", pubOrder)
 
+    /// Bats BZX Exchange. Record for price level book.
+    public static let bzx = try? OrderSource("bzx", pubOrder)
+
     /// Bats Europe BXE Exchange.
     public static let BATE = try? OrderSource("BATE", pubOrder)
 
@@ -168,6 +174,8 @@ public class OrderSource: IndexedEventSource {
     /// Pink sheets are listings for stocks that trade over-the-counter (OTC).
     public static let pink = try? OrderSource("pink", pubOrder | pubOtcMarketsOrder)
 
+    private static var publishableViews = [[OrderSource]](repeating: [OrderSource](), count: flagsSize)
+
     /// Don't use it. Just for initialization all static variable.
     /// static let - is always lazy initialized
     fileprivate static let allValues = [OrderSource.defaultOrderSource,
@@ -186,8 +194,10 @@ public class OrderSource: IndexedEventSource {
                                         OrderSource.ISE,
                                         OrderSource.DEA,
                                         OrderSource.DEX,
+                                        OrderSource.dex,
                                         OrderSource.BYX,
                                         OrderSource.BZX,
+                                        OrderSource.bzx,
                                         OrderSource.BATE,
                                         OrderSource.CHIX,
                                         OrderSource.CEUX,
@@ -208,6 +218,7 @@ public class OrderSource: IndexedEventSource {
                                         OrderSource.iex,
                                         OrderSource.MEMX,
                                         OrderSource.memx,
+                                        OrderSource.OCEA,
                                         OrderSource.pink]
 
     override init(_ identifier: Int, _ name: String) {
@@ -247,6 +258,10 @@ public class OrderSource: IndexedEventSource {
         if !OrderSource.sourcesByName.tryInsert(key: name, value: self) {
             throw ArgumentException.exception("duplicate name \(name)")
         }
+
+        for index in 0..<OrderSource.flagsSize where (pubFlags & (1 << index)) != 0 {
+            OrderSource.publishableViews[index].append(self)
+        }
     }
 
     private static func isFullOrderBookFlag(_ pubFlags: Int) -> Bool {
@@ -304,17 +319,29 @@ public class OrderSource: IndexedEventSource {
         }
         return name
     }
+
     /// Gets a value indicating whether this source supports Full Order Book.
     public func isFullOrderBook() -> Bool {
         return (pubFlags & OrderSource.fullOrderBook) != 0
     }
 
+    /// Returns a list of publishable order sources for a given event type.
+    ///
+    /// - Parameters:
+    ///   - eventype : Possible values ``Order``, ``AnalyticOrder``, ``SpreadOrder``, ``OtcMarketsOrder``
+    /// - Returns: a list of publishable order sources.
+    /// - Throws: ``ArgumentException/exception(_:)``
+    public static func publishable(eventType: AnyClass) throws -> [OrderSource] {
+        let index = Int32(try OrderSource.getEventTypeMask(eventType)).leadingZeroBitCount
+        return publishableViews[31 - index]
+    }
+
     /// Gets a value indicating whether the given event type can be directly published with this source.
     ///
     /// Subscription on such sources can be observed directly via ``DXPublisher``
     /// Subscription on such sources is observed via instances of  ``GenericIndexedEventSubscriptionSymbol``
     /// - Parameters:
-    ///   - eventype : Possible values ``Order``, ``AnalyticOrder``, ``SpreadOrder``
+    ///   - eventype : Possible values ``Order``, ``AnalyticOrder``, ``SpreadOrder``, ``OtcMarketsOrder``
     /// - Returns: true- events can be directly published with this source
     /// - Throws: ``ArgumentException/exception(_:)``
     public func isPublishable(eventType: AnyClass.Type) throws -> Bool {
@@ -345,7 +372,7 @@ public class OrderSource: IndexedEventSource {
     /// Gets type mask by specified event type.
     ///
     /// - Parameters:
-    ///   - eventype : Possible values ``Order``, ``AnalyticOrder``, ``SpreadOrder``
+    ///   - eventype : Possible values ``Order``, ``AnalyticOrder``, ``SpreadOrder``, ``OtcMarketsOrder``
     /// - Returns: The mask for event class.
     /// - Throws: ``ArgumentException/exception(_:)``
     public static func getEventTypeMask(_ eventType: AnyClass) throws -> Int {

DXFeedFramework/Events/Market/Extra/Scope.swift

@@ -20,6 +20,11 @@ public enum Scope: Int, CaseIterable {
 
     /// Represents individual order on the market.
     case order
+
+    var code: Int {
+        return self.rawValue
+    }
+
 }
 
 /// Class extension for ``ScopeExt`` enum.

DXFeedFramework/Extra/IndexedTxModel.swift

@@ -0,0 +1,173 @@
+//
+//
+//  Copyright (C) 2024 Devexperts LLC. All rights reserved.
+//  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+//  If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//  
+
+import Foundation
+
+class IndexedTxModel {
+    class Changes {
+        let isSnapshot: Bool
+        let source: IndexedEventSource
+        let events: [Order]
+
+        init(isSnapshot: Bool,
+             source: IndexedEventSource,
+             events: [Order]) {
+            self.isSnapshot = isSnapshot
+            self.source = source
+            self.events = events
+        }
+    }
+    var mode: TxMode
+    fileprivate var sourceTxDict = [Int: SourceTx]()
+    weak var listener: TxModelListener?
+
+    init(mode: TxMode) {
+        self.mode = mode
+    }
+
+    func setListener(_ listener: TxModelListener) {
+        self.listener = listener
+    }
+}
+
+extension IndexedTxModel: TxModelListener {
+    func modelChanged(changes: Changes) {
+        self.listener?.modelChanged(changes: changes)
+    }
+}
+
+extension IndexedTxModel: DXEventListener {
+    func receiveEvents(_ events: [MarketEvent]) {
+        var sourceTx: SourceTx?
+        events.forEach { marketEvent in
+            guard let order = marketEvent as? Order else {
+                return
+            }
+            let sourceId = order.eventSource.identifier
+            if sourceTx == nil || sourceId != sourceTx?.source.identifier {
+                sourceTx = geTxProcessorForEvent(order)
+            }
+            sourceTx?.processEvent(order)
+        }
+        onBatchReceived()
+    }
+
+    private func geTxProcessorForEvent(_ event: Order) -> SourceTx {
+        let sourceId = event.eventSource.identifier
+        guard let sourceTx = sourceTxDict[sourceId] else {
+            let sourceTx = SourceTx(source: event.eventSource, mode: mode, listener: self)
+            sourceTxDict[sourceId] = sourceTx
+            return sourceTx
+        }
+        return sourceTx
+    }
+
+    private func onBatchReceived() {
+        if mode.isBatchProcessing() {
+            notifyListenerForAllSources()
+        }
+    }
+
+    private func notifyListenerForAllSources() {
+        sourceTxDict.values.forEach { sourceTx in
+            sourceTx.notifyListener()
+        }
+    }
+}
+
+extension IndexedTxModel: Hashable {
+    public static func == (lhs: IndexedTxModel, rhs: IndexedTxModel) -> Bool {
+        return lhs === rhs
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine("\(self):\(stringReference(self))")
+    }
+}
+
+private class SourceTx {
+    private var isPartialSnapshot = false
+    private var isCompleteSnapshot = false
+
+    private weak var snapshotDelegate: SnapshotDelegate?
+    private var pendingEvents = [Order]()
+    private var processedEvents = [Order]()
+
+    let source: IndexedEventSource
+    let mode: TxMode
+
+    weak var listener: TxModelListener?
+
+    init(source: IndexedEventSource,
+         mode: TxMode,
+         listener: TxModelListener) {
+        self.source = source
+        self.mode = mode
+        self.listener = listener
+    }
+
+    func processEvent(_ event: Order) {
+        if event.snapshotBegin() {
+            isPartialSnapshot = true
+            isCompleteSnapshot = false
+            pendingEvents.removeAll()
+        }
+        if isPartialSnapshot && event.endOrSnap() {
+            isPartialSnapshot = false
+            isCompleteSnapshot = true
+        }
+        if event.pending() || isPartialSnapshot {
+            pendingEvents.append(event)
+            return
+        }
+        let isSnapshot = isCompleteSnapshot
+        if isCompleteSnapshot {
+            isCompleteSnapshot = false
+            processedEvents.removeAll()
+        }
+        if !pendingEvents.isEmpty {
+            processedEvents.append(contentsOf: pendingEvents)
+            pendingEvents.removeAll()
+//            if isSnapshot {
+//                pendingEvents.trimToSize()
+//            }
+        }
+        processedEvents.append(event)
+        onTransactionReceived(isSnapshot)
+    }
+    private func onTransactionReceived(_ isSnapshot: Bool) {
+        if mode.isBatchProcessing() {
+            if isSnapshot {
+                notifyListener(true)
+            }
+        } else {
+            notifyListener(isSnapshot)
+        }
+    }
+
+    public func notifyListener() {
+        notifyListener(false)
+    }
+
+    public func notifyListener(_ isSnapshot: Bool) {
+        if processedEvents.isEmpty {
+            return
+        }
+        defer {
+            processedEvents.removeAll()
+            //                if (isSnapshot)
+            //                    pendingEvents.trimToSize();
+        }
+        if listener == nil {
+            return
+        }
+
+        listener?.modelChanged(changes: IndexedTxModel.Changes(isSnapshot: isSnapshot,
+                                                               source: source,
+                                                               events: processedEvents))
+    }
+}

DXFeedFramework/Extra/MarketDepthListener.swift

@@ -0,0 +1,26 @@
+//
+//
+//  Copyright (C) 2024 Devexperts LLC. All rights reserved.
+//  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+//  If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//  
+
+import Foundation
+
+public class OrderBook {
+    public let buyOrders: [Order]
+    public let sellOrders: [Order]
+    public let name = "ASDas"
+    init(buyOrders: [Order], sellOrders: [Order]) {
+        self.buyOrders = buyOrders
+        self.sellOrders = sellOrders
+    }
+
+    public convenience init() {
+        self.init(buyOrders: [Order](), sellOrders: [Order]())
+    }
+}
+
+public protocol MarketDepthListener: AnyObject {
+    func modelChanged(changes: OrderBook)
+}