OnixS C++ CME MDP Premium Market Data Handler 5.9.0
Users' manual and API documentation
Loading...
Searching...
No Matches
FeedSettings.h
Go to the documentation of this file.
1// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
2//
3// This software owned by Onix Solutions Limited [OnixS] and is
4// protected by copyright law and international copyright treaties.
5//
6// Access to and use of the software is governed by the terms of the applicable
7// OnixS Software Services Agreement (the Agreement) and Customer end user license
8// agreements granting a non-assignable, non-transferable and non-exclusive license
9// to use the software for it's own data processing purposes under the terms defined
10// in the Agreement.
11//
12// Except as otherwise granted within the terms of the Agreement, copying or
13// reproduction of any part of this source code or associated reference material
14// to any other location for further reproduction or redistribution, and any
15// amendments to this copyright notice, are expressly prohibited.
16//
17// Any reproduction or redistribution for sale or hiring of the Software not in
18// accordance with the terms of the Agreement is a violation of copyright law.
19//
20
21#pragma once
22
26
28
29// A bit of forward declarations.
30
32
35
38
41void fromStr(HostListSetting&, const std::string&);
42
45{
46public:
47 // Makes assignment more flexible.
48 template <class>
50
53 : group_(group ? *group : SettingGroup::null())
54 , port_(0)
55 , hosts_(group)
56 , nifs_(group)
57 {
58 }
59
63 : group_(SettingGroup::null())
64 , port_(other.port_)
65 , ip_(other.ip_)
66 , hosts_(other.hosts_)
67 , nifs_(other.nifs_)
68 , id_(other.id_)
69 {
70 }
71
74
76 UInt32 port() const
77 {
78 return port_;
79 }
80
83 {
84 group_.controlAssignment("Port", port_, port);
85
86 return *this;
87 }
88
94 const std::string& ip() const
95 {
96 return ip_;
97 }
98
104 FeedConnectionSettings& ip(const std::string& address)
105 {
106 group_.controlAssignment("IP Address", ip_, address);
107
108 return *this;
109 }
110
120 const HostListSetting& hosts() const
121 {
122 return hosts_;
123 }
124
135 {
136 return hosts_;
137 }
138
149 FeedConnectionSettings& hosts(const std::string& hosts)
150 {
151 fromStr(hosts_, hosts);
152
153 return *this;
154 }
155
162 {
163 return nifs_;
164 }
165
172 {
173 return nifs_;
174 }
175
182 FeedConnectionSettings& networkInterfaces(const std::string& interfaces)
183 {
184 fromStr(nifs_, interfaces);
185
186 return *this;
187 }
188
190 const std::string& id() const
191 {
192 return id_;
193 }
194
196 FeedConnectionSettings& id(const std::string& id)
197 {
198 group_.controlAssignment("Identifier", id_, id);
199
200 return *this;
201 }
202
205 {
206 group_.controlChange("Feed Connection Settings", &FeedConnectionSettings::assignNoControl, *this, other);
207
208 return *this;
209 }
210
211private:
212 const SettingGroup& group_;
213
214 UInt32 port_;
215 std::string ip_;
216
217 HostListSetting hosts_;
218 NifListSetting nifs_;
219
220 std::string id_;
221
222 // Non-guarded assignment.
223 void assignNoControl(const FeedConnectionSettings& other)
224 {
225 port_ = other.port_;
226 ip_ = other.ip_;
227
228 hosts_.assignNoControl(other.hosts_);
229 nifs_.assignNoControl(other.nifs_);
230
231 id_ = other.id_;
232 }
233};
234
237void toStr(std::string&, const FeedConnectionSettings&);
238
240inline std::string toStr(const FeedConnectionSettings& settings)
241{
242 std::string str;
243
244 toStr(str, settings);
245
246 return str;
247}
248
250template <typename Layout>
252{
253public:
255 Layout layout() const
256 {
257 return layout_;
258 }
259
262 {
263 group_.controlAssignment("Layout", layout_, value);
264
265 return *this;
266 }
267
275 {
276 return heartbeatInterval_;
277 }
278
281 {
282 group_.controlAssignment("Heartbeat Interval", heartbeatInterval_, interval);
283
284 return *this;
285 }
286
289 {
290 return A_;
291 }
292
295 {
296 return A_;
297 }
298
301 {
302 return B_;
303 }
304
307 {
308 return B_;
309 }
310
311#if !defined(ONIXS_CMEMDH_NO_DEPRECATED)
312
322 FeedSettingsBase& feedANetworkInterfaces(const std::string& interfaces)
323 {
324 A_.networkInterfaces(interfaces);
325
326 return *this;
327 }
328
338 FeedSettingsBase& feedBNetworkInterfaces(const std::string& interfaces)
339 {
340 B_.networkInterfaces(interfaces);
341
342 return *this;
343 }
344#endif // !ONIXS_CMEMDH_NO_DEPRECATED
345
346protected:
347 // Makes assignment more flexible.
349
353 : group_(group ? *group : SettingGroup::null())
354 , layout_(layout)
355 , heartbeatInterval_(heartbeat)
356 , A_(group)
357 , B_(group)
358 {
359 }
360
368 : group_(SettingGroup::null())
369 , layout_(other.layout_)
370 , heartbeatInterval_(other.heartbeatInterval_)
371 , A_(other.A_)
372 , B_(other.B_)
373 {
374 }
375
376 // Finalizes the instance.
378
381 const SettingGroup& group() const
382 {
383 return group_;
384 }
385
390 {
391 layout_ = other.layout_;
392
393 heartbeatInterval_ = other.heartbeatInterval_;
394
395 A_.assignNoControl(other.A_);
396 B_.assignNoControl(other.B_);
397 }
398
399private:
400 const SettingGroup& group_;
401
402 Layout layout_;
403 UInt32 heartbeatInterval_;
404
407
408 FeedSettingsBase& operator=(const FeedSettingsBase& other);
409};
410
445
448void toStr(std::string&, RecoveryFeedLayout::Enum);
449
451inline std::string toStr(RecoveryFeedLayout::Enum layout)
452{
453 std::string str;
454
455 toStr(str, layout);
456
457 return str;
458}
459
462{
463public:
470 : Base(group, RecoveryFeedLayout::FeedAWithFailoverToFeedB, 30)
471 {
472 }
473
476 : Base(static_cast<const Base&>(other))
477 {
478 }
479
482
485 {
486 group().controlChange(
487 "Multicast Recovery Feed Settings", &MulticastRecoveryFeedSettings::assignNoControl, *this, other
488 );
489
490 return *this;
491 }
492
493private:
495
497
498 void assignNoControl(const MulticastRecoveryFeedSettings& other)
499 {
500 Base::assignNoControl(other);
501 }
502};
503
506void toStr(std::string&, const MulticastRecoveryFeedSettings&);
507
509inline std::string toStr(const MulticastRecoveryFeedSettings& settings)
510{
511 std::string str;
512
513 toStr(str, settings);
514
515 return str;
516}
517
519class ONIXS_CMEMDH_LTWT TcpRecoveryFeedSettings : public FeedSettingsBase<RecoveryFeedLayout::Enum>
520{
521public:
528 : Base(group, RecoveryFeedLayout::FeedAOnly, 2)
529 , connectionAttempts_(3)
530 , connectionTimeout_(500)
531 , sendTimeout_(5000)
532 {
533 }
534
538 : Base(static_cast<const Base&>(other))
539 , connectionAttempts_(other.connectionAttempts_)
540 , connectionTimeout_(other.connectionTimeout_)
541 , sendTimeout_(other.sendTimeout_)
542 {
543 }
544
547
554 {
555 return connectionAttempts_;
556 }
557
562 {
563 group().controlAssignment("Connection Attempts", connectionAttempts_, attemptQty);
564
565 return *this;
566 }
567
576 {
577 return connectionTimeout_;
578 }
579
586 {
587 group().controlAssignment("Connection Timeout", connectionTimeout_, connectionTimeout);
588
589 return *this;
590 }
591
598 {
599 return sendTimeout_;
600 }
601
606 {
607 group().controlAssignment("Send Timeout", sendTimeout_, sendTimeout);
608
609 return *this;
610 }
611
615 {
616 group().controlChange("TCP Recovery Feed Settings", &TcpRecoveryFeedSettings::assignNoControl, *this, other);
617
618 return *this;
619 }
620
621private:
622 // Makes assignment more flexible.
624
626
627 UInt32 connectionAttempts_;
628 UInt32 connectionTimeout_;
629 UInt32 sendTimeout_;
630
631 void assignNoControl(const TcpRecoveryFeedSettings& other)
632 {
633 Base::assignNoControl(other);
634
635 connectionAttempts_ = other.connectionAttempts_;
636
637 connectionTimeout_ = other.connectionTimeout_;
638
639 sendTimeout_ = other.sendTimeout_;
640 }
641};
642
645void toStr(std::string&, const TcpRecoveryFeedSettings&);
646
648inline std::string toStr(const TcpRecoveryFeedSettings& settings)
649{
650 std::string str;
651
652 toStr(str, settings);
653
654 return str;
655}
656
694
697void toStr(std::string&, RealtimeFeedLayout::Enum);
698
700inline std::string toStr(RealtimeFeedLayout::Enum layout)
701{
702 std::string str;
703
704 toStr(str, layout);
705
706 return str;
707}
708
710class ONIXS_CMEMDH_LTWT RealtimeFeedSettings : public FeedSettingsBase<RealtimeFeedLayout::Enum>
711{
712public:
718 : Base(group, RealtimeFeedLayout::BothFeedsWithArbitrage, 30)
719 , outOfOrderPacketMaxInterval_(3)
720 , lostPacketWaitTime_(100000)
721 {
722 }
723
727 : Base(static_cast<const Base&>(other))
728 , outOfOrderPacketMaxInterval_(other.outOfOrderPacketMaxInterval_)
729 , lostPacketWaitTime_(other.lostPacketWaitTime_)
730 {
731 }
732
735
765 {
766 return outOfOrderPacketMaxInterval_;
767 }
768
772 {
773 group().controlAssignment("Out Of Order Packet Max Interval", outOfOrderPacketMaxInterval_, intervalLength);
774
775 return *this;
776 }
777
800 {
801 return lostPacketWaitTime_;
802 }
803
807 {
808 group().controlAssignment("Lost Packet Wait Time", lostPacketWaitTime_, waitTime);
809
810 return *this;
811 }
812
816 {
817 group().controlChange("Realtime Feed Settings", &RealtimeFeedSettings::assignNoControl, *this, other);
818
819 return *this;
820 }
821
822private:
824
826
827 UInt32 outOfOrderPacketMaxInterval_;
828 UInt32 lostPacketWaitTime_;
829
830 void assignNoControl(const RealtimeFeedSettings& other)
831 {
832 Base::assignNoControl(other);
833
834 outOfOrderPacketMaxInterval_ = other.outOfOrderPacketMaxInterval_;
835
836 lostPacketWaitTime_ = other.lostPacketWaitTime_;
837 }
838};
839
842void toStr(std::string&, const RealtimeFeedSettings&);
843
845inline std::string toStr(const RealtimeFeedSettings& settings)
846{
847 std::string str;
848
849 toStr(str, settings);
850
851 return str;
852}
853
860{
862 typedef UInt32 Base;
863
869 enum Enum
870 {
874
877 };
878};
879
882void toStr(std::string&, DataCenter::Enum);
883
885inline std::string toStr(DataCenter::Enum layout)
886{
887 std::string str;
888
889 toStr(str, layout);
890
891 return str;
892}
893
897{
898public:
901 : SettingGroup(controller)
902 , packetMaxSize_(1420)
903 , incrementalFeeds_(&group())
904 , instrumentFeeds_(&group())
905 , snapshotFeeds_(&group())
906 , mboSnapshotFeeds_(&group())
907 , historicalFeeds_(&group())
908 , engine_()
909 {
910 }
911
915 : SettingGroup()
916 , packetMaxSize_(other.packetMaxSize_)
917 , incrementalFeeds_(other.incrementalFeeds_)
918 , instrumentFeeds_(other.instrumentFeeds_)
919 , snapshotFeeds_(other.snapshotFeeds_)
920 , mboSnapshotFeeds_(other.mboSnapshotFeeds_)
921 , historicalFeeds_(other.historicalFeeds_)
922 , engine_(other.engine_)
923 {
924 }
925
936 FeedSettings& feedANetworkInterfaces(const std::string& interfaces)
937 {
938 group().controlChange(
939 "Feed A Network Interfaces for All Feeds", &FeedSettings::assignFeedAInterfaces, *this, interfaces
940 );
941
942 return *this;
943 }
944
955 FeedSettings& feedBNetworkInterfaces(const std::string& interfaces)
956 {
957 group().controlChange(
958 "Feed B Network Interfaces for All Feeds", &FeedSettings::assignFeedBInterfaces, *this, interfaces
959 );
960
961 return *this;
962 }
963
968 {
969 return packetMaxSize_;
970 }
971
974 {
975 group().controlAssignment("Packet Max Size", packetMaxSize_, value);
976
977 return *this;
978 }
979
982 {
983 return incrementalFeeds_;
984 }
985
988 {
989 return incrementalFeeds_;
990 }
991
994 {
995 return instrumentFeeds_;
996 }
997
1000 {
1001 return instrumentFeeds_;
1002 }
1003
1006 {
1007 return snapshotFeeds_;
1008 }
1009
1012 {
1013 return snapshotFeeds_;
1014 }
1015
1018 {
1019 return mboSnapshotFeeds_;
1020 }
1021
1024 {
1025 return mboSnapshotFeeds_;
1026 }
1027
1030 {
1031 return historicalFeeds_;
1032 }
1033
1036 {
1037 return historicalFeeds_;
1038 }
1039
1043 {
1044 return engine_.get();
1045 }
1046
1049 {
1050 group().controlAssignment("Feed Engine", engine_, NetFeedEngineController(engine));
1051
1052 return *this;
1053 }
1054
1058 {
1059 group().controlChange("Feed Settings", &FeedSettings::assignNoControl, *this, other);
1060
1061 return *this;
1062 }
1063
1064private:
1066
1067 // To let assignment be controlled
1068 // by the master container.
1070
1073 class ONIXS_CMEMDH_EXPORTED NetFeedEngineController
1074 {
1075 public:
1077 NetFeedEngineController();
1078
1080 explicit NetFeedEngineController(NetFeedEngine*);
1081
1083 NetFeedEngineController(const NetFeedEngineController&);
1084
1086 ~NetFeedEngineController();
1087
1089 NetFeedEngineController& operator=(const NetFeedEngineController& other)
1090 {
1091 NetFeedEngineController tmp(other);
1092 tmp.swap(*this);
1093 return *this;
1094 }
1095
1097 NetFeedEngine* get() const
1098 {
1099 return engine_;
1100 }
1101
1103 void swap(NetFeedEngineController& other)
1104 {
1105 std::swap(engine_, other.engine_);
1106 std::swap(owned_, other.owned_);
1107 }
1108
1109 private:
1110 NetFeedEngine* engine_;
1111 bool owned_;
1112 };
1113
1114 PacketSize packetMaxSize_;
1115
1116 RealtimeFeedSettings incrementalFeeds_;
1117
1118 MulticastRecoveryFeedSettings instrumentFeeds_;
1119 MulticastRecoveryFeedSettings snapshotFeeds_;
1120 MulticastRecoveryFeedSettings mboSnapshotFeeds_;
1121
1122 TcpRecoveryFeedSettings historicalFeeds_;
1123
1124 NetFeedEngineController engine_;
1125
1126 // Casts the given instance to an
1127 // instance of SettingGroup class.
1128 const SettingGroup& group() const
1129 {
1130 return *this;
1131 }
1132
1133 // Re-initializes the given instance
1134 // as a copy of the other one without
1135 // involving assignment control service.
1136 void assignNoControl(const FeedSettings& other)
1137 {
1138 packetMaxSize_ = other.packetMaxSize_;
1139
1140 incrementalFeeds_.assignNoControl(other.incrementalFeeds_);
1141
1142 instrumentFeeds_.assignNoControl(other.instrumentFeeds_);
1143
1144 snapshotFeeds_.assignNoControl(other.snapshotFeeds_);
1145
1146 mboSnapshotFeeds_.assignNoControl(other.mboSnapshotFeeds_);
1147
1148 historicalFeeds_.assignNoControl(other.historicalFeeds_);
1149
1150 engine_ = other.engine_;
1151 }
1152
1153 // Updates interfaces for all primary feeds
1154 // without involving assignment control services.
1155 void assignFeedAInterfaces(const std::string& interfaces)
1156 {
1157 NifListSetting nifs;
1158
1159 fromStr(nifs, interfaces);
1160
1161 incrementalFeeds_.A().networkInterfaces().assignNoControl(nifs);
1162
1163 instrumentFeeds_.A().networkInterfaces().assignNoControl(nifs);
1164
1165 snapshotFeeds_.A().networkInterfaces().assignNoControl(nifs);
1166
1167 mboSnapshotFeeds_.A().networkInterfaces().assignNoControl(nifs);
1168
1169 historicalFeeds_.A().networkInterfaces().assignNoControl(nifs);
1170 }
1171
1172 // Updates interfaces for all primary feeds
1173 // without involving assignment control services.
1174 void assignFeedBInterfaces(const std::string& interfaces)
1175 {
1176 NifListSetting nifs;
1177
1178 fromStr(nifs, interfaces);
1179
1180 incrementalFeeds_.B().networkInterfaces().assignNoControl(nifs);
1181
1182 instrumentFeeds_.B().networkInterfaces().assignNoControl(nifs);
1183
1184 snapshotFeeds_.B().networkInterfaces().assignNoControl(nifs);
1185
1186 mboSnapshotFeeds_.B().networkInterfaces().assignNoControl(nifs);
1187
1188 historicalFeeds_.B().networkInterfaces().assignNoControl(nifs);
1189 }
1190};
1191
1194void toStr(std::string&, const FeedSettings&);
1195
1197inline std::string toStr(const FeedSettings& settings)
1198{
1199 std::string str;
1200
1201 toStr(str, settings);
1202
1203 return str;
1204}
1205
1215 FeedSettings&,
1216 const std::string&,
1217 ChannelId,
1219);
1220
#define ONIXS_CMEMDH_NAMESPACE_BEGIN
Definition Bootstrap.h:67
#define ONIXS_CMEMDH_LTWT
Definition Bootstrap.h:46
#define ONIXS_CMEMDH_LTWT_CLASS_DECL(name)
Definition Bootstrap.h:48
#define ONIXS_CMEMDH_EXPORTED_CLASS_DECL(typeName)
Definition Bootstrap.h:35
#define ONIXS_CMEMDH_NAMESPACE_END
Definition Bootstrap.h:68
#define ONIXS_CMEMDH_NULLPTR
Definition Compiler.h:178
#define ONIXS_CMEMDH_EXPORTED
Definition Compiler.h:171
The collection of parameters defining feed connection.
FeedConnectionSettings & ip(const std::string &address)
const std::string & id() const
The unique connection/feed identifier.
FeedConnectionSettings & operator=(const FeedConnectionSettings &other)
Re-initializes the instance as a copy of the other one.
FeedConnectionSettings(const FeedConnectionSettings &other)
~FeedConnectionSettings()
Finalizes the instance.
const std::string & ip() const
const HostListSetting & hosts() const
FeedConnectionSettings(const SettingGroup *group=nullptr)
Initializes as a blank instance.
FeedConnectionSettings & networkInterfaces(const std::string &interfaces)
const NifListSetting & networkInterfaces() const
FeedConnectionSettings & hosts(const std::string &hosts)
FeedConnectionSettings & port(UInt32 port)
Updates port number for the given connection settings.
FeedConnectionSettings & id(const std::string &id)
Updates the connection/feed identifier.
UInt32 port() const
Port component of the given connection settings.
Collection of parameters which are common for all types of feeds.
const FeedConnectionSettings & B() const
Connection attributes for the secondary (B) feed.
void assignNoControl(const FeedSettingsBase &other)
Layout layout() const
Defines feed layout for a feed group.
FeedSettingsBase & feedANetworkInterfaces(const std::string &interfaces)
FeedSettingsBase & feedBNetworkInterfaces(const std::string &interfaces)
const FeedConnectionSettings & A() const
Connection attributes for the primary (A) feed.
FeedSettingsBase & heartbeatInterval(UInt32 interval)
Specifies maximal time interval between two packets.
FeedConnectionSettings & B()
Connection attributes for the secondary (B) feed.
FeedSettingsBase & layout(Layout value)
Defines feed layout for recovery feed group.
FeedConnectionSettings & A()
Connection attributes for the primary (A) feed.
FeedSettingsBase(const SettingGroup *group, Layout layout, UInt32 heartbeat)
FeedSettingsBase(const FeedSettingsBase &other)
FeedSettings(SettingChangeController *controller=nullptr)
Initializes the instance with the default values.
RealtimeFeedSettings & incrementalFeeds()
The settings related to incremental feeds.
NetFeedEngine * engine() const
FeedSettings(const FeedSettings &other)
FeedSettings & feedANetworkInterfaces(const std::string &interfaces)
const MulticastRecoveryFeedSettings & instrumentFeeds() const
The settings related to instrument feeds.
FeedSettings & packetMaxSize(PacketSize value)
Max size for network packet transmitted by MDP.
FeedSettings & engine(NetFeedEngine *engine)
Defines instance of the Feed Engine to be used by the Handler.
TcpRecoveryFeedSettings & historicalFeeds()
The settings related to historical (TCP Recovery) feeds.
PacketSize packetMaxSize() const
FeedSettings & feedBNetworkInterfaces(const std::string &interfaces)
const MulticastRecoveryFeedSettings & snapshotFeeds() const
The settings related to snapshot feeds.
const RealtimeFeedSettings & incrementalFeeds() const
The settings related to incremental feeds.
MulticastRecoveryFeedSettings & instrumentFeeds()
The settings related to instrument feeds.
FeedSettings & operator=(const FeedSettings &other)
const MulticastRecoveryFeedSettings & mboSnapshotFeeds() const
The settings related to snapshot feeds.
MulticastRecoveryFeedSettings & snapshotFeeds()
The settings related to snapshot feeds.
MulticastRecoveryFeedSettings & mboSnapshotFeeds()
The settings related to snapshot feeds.
const TcpRecoveryFeedSettings & historicalFeeds() const
The settings related to historical (TCP recovery) feeds.
Represents a setting which is a list of values.
ListSetting & assignNoControl(const ListSetting &other)
Collection of parameters affecting recovery feeds behavior.
MulticastRecoveryFeedSettings(const SettingGroup *group=nullptr)
~MulticastRecoveryFeedSettings()
Finalizes the instance.
MulticastRecoveryFeedSettings & operator=(const MulticastRecoveryFeedSettings &other)
Re-initializes the instance as a copy of the other one.
MulticastRecoveryFeedSettings(const MulticastRecoveryFeedSettings &other)
Initializes the instance as a copy of the other one.
Collection of parameters affecting real-time feeds behavior.
RealtimeFeedSettings(const RealtimeFeedSettings &other)
RealtimeFeedSettings & outOfOrderPacketMaxInterval(UInt32 intervalLength)
~RealtimeFeedSettings()
Finalizes the instance.
RealtimeFeedSettings & operator=(const RealtimeFeedSettings &other)
RealtimeFeedSettings & lostPacketWaitTime(UInt32 waitTime)
RealtimeFeedSettings(const SettingGroup *group=nullptr)
Base services for settings grouped by a certain criteria.
void controlAssignment(const Char *description, Assignee &assignee, Value value) const
SettingGroup(SettingChangeController *controller=nullptr)
void controlChange(const Char *description, void(Changeable::*change)(), Changeable &changeable) const
Collection of parameters affecting recovery feeds behavior.
TcpRecoveryFeedSettings & connectionAttempts(UInt32 attemptQty)
TcpRecoveryFeedSettings & operator=(const TcpRecoveryFeedSettings &other)
~TcpRecoveryFeedSettings()
Finalizes the instance.
TcpRecoveryFeedSettings(const SettingGroup *group=nullptr)
TcpRecoveryFeedSettings & connectionTimeout(UInt32 connectionTimeout)
TcpRecoveryFeedSettings(const TcpRecoveryFeedSettings &other)
TcpRecoveryFeedSettings & sendTimeout(UInt32 sendTimeout)
ListSetting< std::string > HostListSetting
List of hosts as a setting.
bool fromStr(Decimal &, const Char *, size_t)
void connectivityFromConfiguration(FeedSettings &, const std::string &, ChannelId, DataCenter::Enum=DataCenter::Primary)
void toStr(std::string &, BookState::Enum)
Serializes book state value into a string.
UInt32 UInt32
uInt32.
Definition Fields.h:202
HostListSetting NifListSetting
List of network interfaces as a setting.
UInt16 PacketSize
Integral type for measuring packets.
UInt32 ChannelId
Identifies CME channel.
Definition Domain.h:28
@ DisasterRecovery
Indicates data center used in case of disaster.
@ FeedBOnly
Indicates only feed B is used as source for market data.
@ BothFeedsWithArbitrage
Handler arbitrates between both feeds A and B.
@ FeedAOnly
Indicates only feed A is used as source for market data.
@ FeedBOnly
Indicates only feed B is used as source for market data.
@ FeedAOnly
Indicates only feed A is used as source for market data.