OnixS C++ CME MDP Premium Market Data Handler 5.9.0
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)
Updates address component of the given connection settings.
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)
Initializes the given instance as a copy of the other one.
HostListSetting & hosts()
Updates list of hosts for the given connection settings.
~FeedConnectionSettings()
Finalizes the instance.
const std::string & ip() const
Indicates address component of the given connection settings.
const HostListSetting & hosts() const
Indicates host list of the given connection settings.
NifListSetting & networkInterfaces()
List of network interfaces for the given connection settings.
FeedConnectionSettings(const SettingGroup *group=nullptr)
Initializes as a blank instance.
FeedConnectionSettings & networkInterfaces(const std::string &interfaces)
Specifies one or more network interfaces on which to join the multicast group if the settings define ...
const NifListSetting & networkInterfaces() const
List of network interfaces for the given connection settings.
FeedConnectionSettings & hosts(const std::string &hosts)
Updates list of hosts for the given connection settings from a string representing comma or semi-colo...
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)
Re-initializes the instance as a copy of the other one without involving assignment control services.
Layout layout() const
Defines feed layout for a feed group.
FeedSettingsBase & feedANetworkInterfaces(const std::string &interfaces)
Specifies one or more network interfaces to use for primary (A) feeds while joining the multicast gro...
FeedSettingsBase & feedBNetworkInterfaces(const std::string &interfaces)
Specifies one or more network interfaces to use for secondary (B) feeds while joining the multicast g...
UInt32 heartbeatInterval() const
Specifies maximal time interval between two network packets.
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)
Initializes the instance with the given values and optional grouping.
FeedSettingsBase(const FeedSettingsBase &other)
Initializes the instance as a copy of the other one.
The parameters affecting all feeds involved into market data processing.
FeedSettings(SettingChangeController *controller=nullptr)
Initializes the instance with the default values.
RealtimeFeedSettings & incrementalFeeds()
The settings related to incremental feeds.
NetFeedEngine * engine() const
Instance of the Feed Engine to be used by the Handler.
FeedSettings(const FeedSettings &other)
Initializes the instance as a copy of the other one.
FeedSettings & feedANetworkInterfaces(const std::string &interfaces)
Specifies one or more network interfaces on which to join multicast groups referring to primary (A) f...
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
Max size for network packet transmitted by MDP.
FeedSettings & feedBNetworkInterfaces(const std::string &interfaces)
Specifies one or more network interfaces on which to join multicast groups referring to secondary (B)...
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)
Re-initializes the instance as a copy of the other one.
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)
Unmanaged assignment of the list.
Collection of parameters affecting recovery feeds behavior.
MulticastRecoveryFeedSettings(const SettingGroup *group=nullptr)
Initializes instance with default values.
~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.
Abstraction for the Feed Engine machinery.
Definition FeedEngine.h:102
Collection of parameters affecting real-time feeds behavior.
RealtimeFeedSettings(const RealtimeFeedSettings &other)
Initializes the instance as a copy of the other one.
RealtimeFeedSettings & outOfOrderPacketMaxInterval(UInt32 intervalLength)
Defines value of threshold used by the Handler while handling out-of-order incoming packets.
~RealtimeFeedSettings()
Finalizes the instance.
RealtimeFeedSettings & operator=(const RealtimeFeedSettings &other)
Re-initializes the instance as a copy of the other one.
RealtimeFeedSettings & lostPacketWaitTime(UInt32 waitTime)
Defines the time limit for the Handler while waiting for expected packets before they considered as l...
RealtimeFeedSettings(const SettingGroup *group=nullptr)
Initializes instance with default values.
UInt32 lostPacketWaitTime() const
Indicates the time limit for the Handler while waiting for expected packets before they are considere...
UInt32 outOfOrderPacketMaxInterval() const
Defines a threshold used by the Handler while handling out-of-order incoming packets.
Base services for settings grouped by a certain criteria.
void controlAssignment(const Char *description, Assignee &assignee, Value value) const
Guarded assignment of the given value to the given variable.
SettingGroup(SettingChangeController *controller=nullptr)
Initializes the group of settings with the given validation services.
void controlChange(const Char *description, void(Changeable::*change)(), Changeable &changeable) const
Guarded invoke of the given routine which assumes complex change or update for the given object.
Collection of parameters affecting recovery feeds behavior.
TcpRecoveryFeedSettings & connectionAttempts(UInt32 attemptQty)
Number of times the Handler must try recovering from the other feed if it fails to recover from the p...
TcpRecoveryFeedSettings & operator=(const TcpRecoveryFeedSettings &other)
Re-initializes the instance as a copy of the other one.
UInt32 connectionAttempts() const
Number of times the Handler must try recovering from the other feed if it fails to recover from the p...
~TcpRecoveryFeedSettings()
Finalizes the instance.
UInt32 connectionTimeout() const
Interval between the attempts to receive missed packets via the TCP recovery feed if previous attempt...
UInt32 sendTimeout() const
Time limit for the send operation.
TcpRecoveryFeedSettings(const SettingGroup *group=nullptr)
Initializes instance with default values.
TcpRecoveryFeedSettings & connectionTimeout(UInt32 connectionTimeout)
Interval between the attempts to receive missed packets via the TCP recovery feed if previous attempt...
TcpRecoveryFeedSettings(const TcpRecoveryFeedSettings &other)
Initializes the instance as a copy of the other one.
TcpRecoveryFeedSettings & sendTimeout(UInt32 sendTimeout)
Time limit for the send operation.
ListSetting< std::string > HostListSetting
List of hosts as a setting.
bool fromStr(Decimal &, const Char *, size_t)
Deserializes a decimal number from the given text presentation.
void connectivityFromConfiguration(FeedSettings &, const std::string &, ChannelId, DataCenter::Enum=DataCenter::Primary)
Retrieves connection settings from the given connectivity configuration file for the given channel an...
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
To optimally service customers and meet regulatory requirements for out-of-region recovery capabiliti...
Enum
To optimally service customers and meet regulatory requirements for out-of-region recovery capabiliti...
@ DisasterRecovery
Indicates data center used in case of disaster.
@ Primary
Indicates the primary data center, which houses all CME applications.
Defines feed layout alternates available for real-time feed like incremental one.
@ FeedBOnly
Indicates only feed B is used as source for market data.
@ FeedBWithFailoverToFeedA
Feed B is used as primary source of market data.
@ BothFeedsWithArbitrage
Handler arbitrates between both feeds A and B.
@ FeedAWithFailoverToFeedB
Feed A is used as primary source of market data.
@ FeedAOnly
Indicates only feed A is used as source for market data.
Defines feed layout alternates available for recovery feeds like instrument and snapshot.
@ FeedBOnly
Indicates only feed B is used as source for market data.
@ FeedBWithFailoverToFeedA
Feed B is used as primary source of market data.
@ FeedAWithFailoverToFeedB
Feed A is used as primary source of market data.
@ FeedAOnly
Indicates only feed A is used as source for market data.
Represents a service controlling change/update operations for the collections of settings.