OnixS C++ CME Market Data Handler  5.7.0
API documentation
SessionSettings.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 
23 #include <string>
24 
25 #include <OnixS/CME/MDH/Integral.h>
27 
29 
30 /// Defines type of recovery to be done
31 /// by Handler at the time it joins market.
34 {
35  /// Integral type serving as
36  /// basement for given enumeration.
37  typedef UInt32 Base;
38 
39  /// Defines type of recovery to be done
40  /// by Handler while it joins market.
41  enum Enum
42  {
43  /// No recovery is to be done at join time.
44  /// Handler will switch to real-time data
45  /// processing immediately.
47 
48  /// Instructs Handler to recover instruments before
49  /// switching to real-time (incremental data) processing.
51 
52  /// Instructs Handler to perform full recovery (both instruments
53  /// and market state (books, last trades, statistics, etc))
54  /// before switching to real-time (incremental) data processing.
55  InstrumentsAndMarketState
56  };
57 };
58 
59 /// Serializes join recovery option.
60 ONIXS_CMEMDH_EXPORTED
61 void
62 toStr(
63  std::string&,
65 
66 /// Serializes join recovery option.
67 inline
68 std::string
71 {
72  std::string str;
73 
74  toStr(str, recovery);
75 
76  return str;
77 }
78 
79 /// Defines the way Handler has to handle
80 /// gap in real-time (incremental) data.
83 {
84  /// Integral type serving as
85  /// basement for given enumeration.
86  typedef UInt32 Base;
87 
88  /// Defines the way Handler has to handle
89  /// gap in real-time (incremental) data.
90  enum Enum
91  {
92  /// Handler recovers market state from snapshots.
94 
95  /// Handler recovers instruments and market state afterwards.
97 
98  /// Handler continues processing of real-time market data.
99  ContinueProcessing
100  };
101 };
102 
103 /// Serializes gap and error handling option.
104 ONIXS_CMEMDH_EXPORTED
105 void
106 toStr(
107  std::string&,
109 
110 /// Serializes gap and error handling option.
111 inline
112 std::string
115 {
116  std::string str;
117 
118  toStr(str, handling);
119 
120  return str;
121 }
122 
123 /// Defines different ways of instrument definition recovery.
126 {
127  /// Integral type used as basement for constants.
128  typedef UInt32 Base;
129 
130  enum Enum
131  {
132  /// The given strategy tells the Handler to recover instruments
133  /// in the most accurate way. In particular, the Handler processes
134  /// instrument definitions from the beginning of a recovery loop.
135  /// If the Handler joins instrument recovery feed in the middle
136  /// of a recovery loop, incoming data is ignored until a new loop
137  /// begins. Also, if the Handler detects gap in a sequence of
138  /// incoming packets, it will stop processing instrument definitions
139  /// till the end of a loop and restart the recovery from the beginning
140  /// of a new loop.
141  /// The given way to recover instruments is highly recommended for
142  /// the channels, where user-defined instruments are frequently added
143  /// or removed during the trading week.
144  /// Accurate recovery may take longer due to necessity to wait for
145  /// the beginning of a new loop caused by join at the middle of a
146  /// prior loop or data loss.
148 
149  /// The fast mode allows to start processing instrument definitions
150  /// from the middle of a recovery loop without waiting for the beginning
151  /// of the next loop. In case of data loss, missing definitions are
152  /// recovered from the next loops. The given approach allows to recover
153  /// quickly. However, the recovered set of instruments may not be accurate
154  /// because of differences in the recovery loops from where the recovery
155  /// data was taken.
156  Fast
157  };
158 };
159 
160 /// Serializes instrument definition recovery strategy.
161 ONIXS_CMEMDH_EXPORTED
162 void
163 toStr(
164  std::string&,
166 
167 /// Serializes instrument definition recovery strategy.
168 inline
169 std::string
172 {
173  std::string str;
174 
175  toStr(str, option);
176 
177  return str;
178 }
179 
180 /// Defines market state recovery options.
183 {
184  /// Integral type serving as
185  /// basement for given enumeration.
186  typedef UInt32 Base;
187 
188  enum Enum
189  {
190  /// Only market by price books will be
191  /// recovered during market state recovery.
193 
194  /// Only market by order books will be
195  /// recovered during market state recovery.
197 
198  /// Both market by price and market by order
199  /// books will be recovered during market
200  /// state recovery.
201  BothMboAndMbp
202  };
203 };
204 
205 /// Serializes market recovery option.
206 ONIXS_CMEMDH_EXPORTED
207 void
208 toStr(
209  std::string&,
211 
212 /// Serializes market recovery option.
213 inline
214 std::string
217 {
218  std::string str;
219 
220  toStr(str, option);
221 
222  return str;
223 }
224 
226 (
228 );
229 
230 /// Collection of session settings related to TCP recovery.
233 {
234  /// Lets grouping and value assignment control functioning.
235  friend
237  (
239  );
240 
241  //
242 
243  const SettingGroup& group_;
244 
245  TcpRecoveryService* service_;
246 
247  UInt32 attempts_;
248  UInt32 servingTimeLimit_;
249 
250  // Re-initializes the instance as a copy of the
251  // other one and bypassing assignment control.
252  void
253  assignNoControl(
254  const
256  {
257  service_ =
258  other.service_;
259 
260  attempts_ =
261  other.attempts_;
262 
263  servingTimeLimit_ =
264  other.servingTimeLimit_;
265  }
266 
267 public:
268  /// Initializes the instance with the default values.
269  ///
270  /// Optional group parameter lets to make the
271  /// instance belonging to a given group of settings.
273  const SettingGroup* group = NULL)
274  : group_(
275  group
276  ? *group
277  : SettingGroup::null())
278  , service_(NULL)
279  , attempts_(1)
280  , servingTimeLimit_(10)
281  {
282  }
283 
284  /// Initializes the instance as a copy
285  /// of the other one. Grouping and value
286  /// assignment control services are not
287  /// copied.
289  const TcpRecoverySessionSettings& other)
290  : group_(SettingGroup::null())
291  , service_(other.service_)
292  , attempts_(other.attempts_)
293  , servingTimeLimit_(
294  other.servingTimeLimit_)
295  {
296  }
297 
298  /// Finalizes the instance.
300  {
301  }
302 
303  /// An instance of the TCP recovery
304  /// service if there's any associated.
305  ///
306  /// Null instance indicates no service is
307  /// associated and thus TCP recovery is disabled
308  /// during market data processing session.
310  service() const
311  {
312  return service_;
313  }
314 
315  /// Associates the instance of the TCP Recovery
316  /// service to be used by a Handler during market
317  /// data processing session.
319  service(
320  TcpRecoveryService* service)
321  {
322  group_.
323  controlAssignment
324  (
325  "TCP Recovery Service Instance",
326  service_,
327  service
328  );
329 
330  return *this;
331  }
332 
333  /// Number of times a Handler must try to recover
334  /// missing data using the TCP recovery before it
335  /// switches to recover market state from snapshots
336  /// or resumes incremental data processing by natural
337  /// refresh.
338  UInt32
339  attempts() const
340  {
341  return attempts_;
342  }
343 
344  /// Updates number of times a Handler must try
345  /// to recover missing data using the TCP recovery
346  /// before it switches to recover market state from
347  /// snapshots or resumes incremental data processing
348  /// by natural refresh.
350  attempts(
351  UInt32 qty)
352  {
353  group_.
354  controlAssignment
355  (
356  "TCP Recovery Attempt Quantity",
357  attempts_,
358  qty
359  );
360 
361  return *this;
362  }
363 
364  /// Amount of time allocated to process a
365  /// recovery request. TCP recovery service
366  /// interrupts request processing if it can't
367  /// be accomplished within given time frame.
368  ///
369  /// Interval is measured in seconds.
370  ///
371  /// @note Default value is '10'.
372  UInt32
373  servingTimeLimit() const
374  {
375  return servingTimeLimit_;
376  }
377 
378  /// Amount of time allocated to process a
379  /// recovery request. TCP recovery service
380  /// interrupts request processing if it can't
381  /// be accomplished within given time frame.
382  ///
383  /// Interval is measured in seconds.
385  servingTimeLimit(
386  UInt32 servingTimeLimit)
387  {
388  group_.
389  controlAssignment
390  (
391  "TCP Recovery Serving Time Limit",
392  servingTimeLimit_,
393  servingTimeLimit
394  );
395 
396  return *this;
397  }
399  /// Re-initializes as a copy of the other one. Grouping
400  /// and value assignment control services aren't copied.
402  operator =(
403  const
405  {
406  group_.
407  controlChange
408  (
409  "TCP Recovery Session Settings",
410  &TcpRecoverySessionSettings::assignNoControl,
411  *this,
412  other
413  );
414 
415  return *this;
416  }
417 };
418 
419 /// Serializes market recovery option.
420 ONIXS_CMEMDH_EXPORTED
421 void
422 toStr(
423  std::string&,
424  const
426 
427 /// Serializes market recovery option.
428 inline
429 std::string
431  const
432  TcpRecoverySessionSettings& settings)
433 {
434  std::string str;
435 
436  toStr(str, settings);
437 
438  return str;
439 }
440 
441 /// Basic set of parameters affecting behavior of the
442 /// Handler when the market data processing is performed.
443 ///
444 /// @note The given class exists to provide backward compatibility
445 /// with the previous releases. Use 'AdvancedSessionSettings' instead.
447 {
448  JoinRecoveryOptions::Enum joinRecovery_;
449  GapAndErrorHandlingOptions::Enum gapAndErrorHandling_;
450 
451  InstrumentRecoveryOptions::Enum instrumentRecovery_;
452  MarketRecoveryOptions::Enum marketRecovery_;
453 
454 protected:
455  /// Instance of the group to which
456  /// the given settings belongs.
457  const
458  SettingGroup&
459  group() const
460  {
461  return *this;
462  }
463 
464  /// Re-initializes the instance as a copy of the
465  /// other one and bypassing assignment control.
466  void
468  const SessionSettings& other)
469  {
470  joinRecovery_ =
471  other.joinRecovery_;
472 
473  gapAndErrorHandling_ =
474  other.gapAndErrorHandling_;
475 
476  instrumentRecovery_ =
477  other.instrumentRecovery_;
478 
479  marketRecovery_ =
480  other.marketRecovery_;
481  }
482 
483 public:
484  /// Initializes parameters with default values.
487  controller = NULL)
488  : SettingGroup(controller)
489  , joinRecovery_(
491  InstrumentsAndMarketState)
492  , gapAndErrorHandling_(
494  RecoverMarketState)
495  , instrumentRecovery_(
497  Accurate)
498  , marketRecovery_(
500  BothMboAndMbp)
501  {
502  }
503 
504  /// Re-initializes settings as copies of
505  /// the other ones omitting group belonging.
507  const SessionSettings& other)
508  : SettingGroup()
509  , joinRecovery_(
510  other.joinRecovery_)
511  , gapAndErrorHandling_(
512  other.gapAndErrorHandling_)
513  , instrumentRecovery_(
514  other.instrumentRecovery_)
515  , marketRecovery_(
516  other.marketRecovery_)
517  {
518  }
519 
520  /// Cleans everything up.
522  {
523  }
524 
525  /// Defines aspects of recovery
526  /// to be done at market join stage.
527  ///
528  /// @note Default value is
529  /// JoinRecovery::InstrumentsAndMarket.
531  joinRecovery() const
532  {
533  return joinRecovery_;
534  }
535 
536  /// Defines aspects of recovery
537  /// to be done at market join stage.
540  JoinRecoveryOptions::Enum recovery)
541  {
542  group().
543  controlAssignment
544  (
545  "Join Recovery Strategy",
546  joinRecovery_,
547  recovery
548  );
549 
550  return *this;
551  }
552 
553  /// Defines what Handler should do in case
554  /// of gap in real-time (incremental) data.
555  ///
556  /// @note Default value is
557  /// GapAndErrorHandling::RecoverMarketState.
560  {
561  return gapAndErrorHandling_;
562  }
563 
564  /// Defines what Handler should do in case
565  /// of gap in real-time (incremental) data.
569  {
570  group().
571  controlAssignment
572  (
573  "Gap And Error Handling Strategy",
574  gapAndErrorHandling_,
575  handling
576  );
577 
578  return *this;
579  }
580 
581  /// Indicates how instrument definitions are recovered.
582  ///
583  /// @note Default value is InstrumentRecoveryOptions::Accurate.
586  {
587  return instrumentRecovery_;
588  }
589 
590  /// Defines how instrument definitions are recovered.
594  {
595  group().
596  controlAssignment
597  (
598  "Instrument Recovery Strategy",
599  instrumentRecovery_,
600  recovery
601  );
602 
603  return *this;
604  }
605 
606  /// Defines selected market recovery options.
607  ///
608  /// @note Default value is MarketRecovery::BothMboAndMbp.
611  {
612  return marketRecovery_;
613  }
614 
615  /// Defines market recovery options.
619  {
620  group().
621  controlAssignment
622  (
623  "Market Recovery Strategy",
624  marketRecovery_,
625  recovery
626  );
627 
628  return *this;
629  }
630 
631  /// Copies settings from the given instance.
632  ///
633  /// Attributes controlling value assignment aren't
634  /// cloned and thus only settings' values are copied.
636  operator =(
637  const SessionSettings& other)
638  {
639  group().
640  controlChange
641  (
642  "Session Settings",
643  &SessionSettings::assignNoControl,
644  *this,
645  other
646  );
647 
648  return *this;
649  }
650 };
651 
652 /// Serializes market data processing session settings.
653 ONIXS_CMEMDH_EXPORTED
654 void
655 toStr(
656  std::string&,
657  const SessionSettings&);
658 
659 /// Serializes market data processing session settings.
660 inline
661 std::string
663  const SessionSettings& settings)
664 {
665  std::string str;
666 
667  toStr(str, settings);
668 
669  return str;
670 }
671 
672 /// Full set of parameters affecting behavior
673 /// of the Handler when market data is processed.
676  : public SessionSettings
677 {
678  // Lets grouping and value assignment control functioning.
680 
681  TcpRecoverySessionSettings tcpRecovery_;
682 
683  // Re-initializes the instance as a copy of the
684  // other one and bypassing assignment control.
685  void
686  assignNoControl(
687  const AdvancedSessionSettings& other)
688  {
689  SessionSettings::assignNoControl(other);
690 
691  tcpRecovery_.assignNoControl(other.tcpRecovery_);
692  }
693 
694 public:
695  /// Initializes parameters with default values.
698  controller = NULL)
699  : SessionSettings(controller)
700  , tcpRecovery_(&group())
701  {
702  }
703 
704  /// Re-initializes settings as copies of
705  /// the other ones omitting group belonging.
707  const AdvancedSessionSettings& other)
708  : SessionSettings(
709  static_cast
710  <const SessionSettings&>
711  (other))
712  , tcpRecovery_(
713  other.tcpRecovery_)
714  {
715  }
716 
717  /// Cleans everything up.
719  {
720  }
721 
722  /// Set of TCP recovery settings.
723  const
725  tcpRecovery() const
726  {
727  return tcpRecovery_;
728  }
729 
730  /// Editable set of TCP recovery settings.
733  {
734  return tcpRecovery_;
735  }
736 
737  /// Copies settings from the given instance.
738  ///
739  /// Attributes controlling value assignment aren't
740  /// cloned and thus only settings' values are copied.
742  operator =(
743  const AdvancedSessionSettings& other)
744  {
745  group().
746  controlChange
747  (
748  "Advanced Session Settings",
749  &AdvancedSessionSettings::assignNoControl,
750  *this,
751  other
752  );
753 
754  return *this;
755  }
756 };
757 
758 /// Serializes market data processing session settings.
759 ONIXS_CMEMDH_EXPORTED
760 void
761 toStr(
762  std::string&,
763  const AdvancedSessionSettings&);
764 
765 /// Serializes market data processing session settings.
766 inline
767 std::string
769  const
770  AdvancedSessionSettings& settings)
771 {
772  std::string str;
773 
774  toStr(str, settings);
775 
776  return str;
777 }
778 
779 // Various functions helping in configuring session in the desired way.
780 
781 /// Updates session settings to tell the Handler
782 /// to recover instruments using accurate strategy
783 /// each time instrument recovery is performed.
784 inline
785 void
787 (
788  SessionSettings& settings
789 )
790 {
791  settings.
792  instrumentRecovery(
794  Accurate);
795 }
796 
797 /// Updates session settings to tell the Handler
798 /// to recover instruments using fast strategy each
799 /// time instrument recovery is performed.
800 inline
801 void
803 (
804  SessionSettings& settings
805 )
806 {
807  settings.
808  instrumentRecovery(
810  Fast);
811 }
812 
813 /// Updates session settings to tell the Handler
814 /// to skip join-time recovery and switch processing
815 /// incremental (real-time) data.
816 inline
817 void
819 (
820  SessionSettings& settings
821 )
822 {
823  settings.
824  joinRecovery(
826  Disabled);
827 }
828 
829 /// Updates session settings to tell the Handler
830 /// to recover instruments and market state before
831 /// it switches processing incremental data.
832 inline
833 void
835  SessionSettings& settings)
836 {
837  settings.
838  joinRecovery(
840  InstrumentsAndMarketState);
841 }
842 
843 
844 /// Updates session settings to recover
845 /// books of all types each time the Handler
846 /// recovers market state from snapshots.
847 inline
848 void
850 (
851  SessionSettings& settings
852 )
853 {
854  settings.
855  marketRecovery(
857  BothMboAndMbp);
858 }
859 
860 /// Updates session settings to recover
861 /// MBO books only each time the Handler
862 /// recovers market state from snapshots.
863 inline
864 void
866 (
867  SessionSettings& settings
868 )
869 {
870  settings.
871  marketRecovery(
873  MboOnly);
874 }
875 
876 /// Updates session settings to recover
877 /// MBP books only each time the Handler
878 /// recovers market state from snapshots.
879 inline
880 void
882 (
883  SessionSettings& settings
884 )
885 {
886  settings.
887  marketRecovery(
889  MbpOnly);
890 }
891 
892 /// Updates session settings to tell the
893 /// Handler to recover instruments and market
894 /// state (books) in case of gap or other issue.
895 inline
896 void
898 (
899  SessionSettings& settings
900 )
901 {
902  settings.
903  gapAndErrorHandling(
905  RecoverInstrumentsAndMarketState);
906 }
907 
908 /// Updates session settings to tell the
909 /// Handler to recover market state (books)
910 /// in case of gap or other issue.
911 inline
912 void
914 (
915  SessionSettings& settings
916 )
917 {
918  settings.
919  gapAndErrorHandling(
921  RecoverMarketState);
922 }
923 
924 /// Updates session settings to tell the Handler
925 /// continue processing incremental (real-time)
926 /// data in case of gap or other issue.
927 inline
928 void
930 (
931  SessionSettings& settings
932 )
933 {
934  settings.
935  gapAndErrorHandling(
937  ContinueProcessing);
938 }
939 
940 // Complex (one-call) setup.
941 
942 /// Configures session to maintain order books
943 /// accurately and without performing initial
944 /// (late-join) recovery thus considering market
945 /// data processing is started from the beginning
946 /// of weekly session.
947 inline
948 void
950 (
951  SessionSettings& settings
952 )
953 {
955  (
956  settings
957  );
959  (
960  settings
961  );
963  (
964  settings
965  );
967  (
968  settings
969  );
970 }
971 
972 /// Configures session to maintain order
973 /// books accurately and considering market
974 /// data processing is started at the middle
975 /// of weekly session (late join).
976 inline
977 void
979 (
980  SessionSettings& settings
981 )
982 {
984  (
985  settings
986  );
988  (
989  settings
990  );
992  (
993  settings
994  );
996  (
997  settings
998  );
999 }
1000 
1001 /// Configures session settings to maintain
1002 /// order books using natural refresh. Startup
1003 /// recovery is not performed and thus only
1004 /// real-time processing takes place.
1005 inline
1006 void
1008  SessionSettings& settings)
1009 {
1011  (
1012  settings
1013  );
1015  (
1016  settings
1017  );
1018 }
1019 
1020 // Deprecated way of session setup.
1021 
1022 #if !defined (ONIXS_CMEMDH_NO_DEPRECATED)
1023 
1024 /// Settings for session with accurate book
1025 /// maintenance and considering market data
1026 /// processing is started from the beginning
1027 /// of weekly session.
1031 {
1032  /// Configures session settings
1033  /// according to specialization.
1035  {
1037  }
1038 };
1039 
1040 /// Settings for session with accurate book maintenance
1041 /// and considering market data processing is started
1042 /// from the beginning of weekly session. Market recovery
1043 /// is limited to recovery market by order books only.
1047 {
1048  /// Configures session settings
1049  /// according to specialization.
1051  {
1054  }
1055 };
1056 
1057 /// Settings for session with accurate book maintenance
1058 /// and considering market data processing is started
1059 /// from the beginning of weekly session. Market recovery
1060 /// is limited to recovery market by price books only.
1064 {
1065  /// Configures session settings
1066  /// according to specialization.
1068  {
1071  }
1072 };
1073 
1074 /// Settings for session with accurate book
1075 /// maintenance and considering market data
1076 /// processing is started at the middle of
1077 /// weekly session (late join).
1081 {
1082  /// Configures session settings
1083  /// according to specialization.
1085  : SessionSettings()
1086  {
1088  }
1089 };
1090 
1091 /// Settings for session with accurate book maintenance
1092 /// and considering market data processing is started at
1093 /// the middle of weekly session (late join). Market recovery
1094 /// is limited to recover market by order books only.
1098 {
1099  /// Configures session settings
1100  /// according to specialization.
1102  {
1105  }
1106 };
1107 
1108 /// Settings for session with accurate book maintenance
1109 /// and considering market data processing is started at
1110 /// the middle of weekly session (late join). Market recovery
1111 /// is limited to recover market by price books only.
1115 {
1116  /// Configures session settings
1117  /// according to specialization.
1119  {
1122  }
1123 };
1124 
1125 /// Configures session settings to maintain
1126 /// order books using natural refresh. Startup
1127 /// recovery is not performed and thus only
1128 /// real-time processing takes place.
1132 {
1133  /// Configures session settings
1134  /// according to specialization.
1136  : SessionSettings()
1137  {
1139  }
1140 };
1141 
1142 #endif // ONIXS_CMEMDH_NO_DEPRECATED
1143 
#define ONIXS_CMEMDH_LTWT_CLASS
Definition: Bootstrap.h:94
void setSessionToRecoverInstrumentsFast(SessionSettings &settings)
Handler&#39;s configuration settings.
void setSessionToRecoverBothMboAndMbpBooks(SessionSettings &settings)
AdvancedSessionSettings(SettingChangeController *controller=NULL)
Initializes parameters with default values.
void setSessionToRecoverBooksUponRealtimeIssues(SessionSettings &settings)
Collection of session settings related to TCP recovery.
UInt32 UInt32
uInt32.
Definition: Fields.h:247
void setSessionToRecoverMbpBooksOnly(SessionSettings &settings)
SessionSettings & marketRecovery(MarketRecoveryOptions::Enum recovery)
Defines market recovery options.
void assignNoControl(const SessionSettings &other)
void setSessionToLateJoin(SessionSettings &settings)
Handler recovers market state from snapshots.
~SessionSettings()
Cleans everything up.
#define ONIXS_CMEMDH_EXPORTED_CLASS_DECL(typeName)
Definition: Bootstrap.h:46
void setSessionToJoinInPreopening(SessionSettings &settings)
SessionSettings & gapAndErrorHandling(GapAndErrorHandlingOptions::Enum handling)
#define ONIXS_CMEMDH_LTWT_STRUCT
Definition: Bootstrap.h:98
Handler recovers instruments and market state afterwards.
SessionSettings(const SessionSettings &other)
#define ONIXS_CMEMDH_NAMESPACE_BEGIN
Definition: Bootstrap.h:152
const TcpRecoverySessionSettings & tcpRecovery() const
Set of TCP recovery settings.
Base services for settings grouped by a certain criteria.
Definition: SettingGroup.h:124
std::string toStr(const AdvancedSessionSettings &settings)
Serializes market data processing session settings.
Defines different ways of instrument definition recovery.
const SettingGroup & group() const
SessionSettings & joinRecovery(JoinRecoveryOptions::Enum recovery)
void setSessionToRecoverMboBooksOnly(SessionSettings &settings)
UInt32 Base
Integral type used as basement for constants.
~AdvancedSessionSettings()
Cleans everything up.
#define ONIXS_CMEMDH_LTWT_CLASS_DECL(name)
Definition: Bootstrap.h:106
void setSessionToContinueRealtimeProcessingUponIssues(SessionSettings &settings)
void setSessionToAccurateLateJoin(SessionSettings &settings)
GapAndErrorHandlingOptions::Enum gapAndErrorHandling() const
SessionSettings & instrumentRecovery(InstrumentRecoveryOptions::Enum recovery)
Defines how instrument definitions are recovered.
MarketRecoveryOptions::Enum marketRecovery() const
void setSessionToNaturalRefresh(SessionSettings &settings)
void setSessionToFullRecoverUponRealtimeIssues(SessionSettings &settings)
Defines market state recovery options.
TcpRecoverySessionSettings & tcpRecovery()
Editable set of TCP recovery settings.
AdvancedSessionSettings(const AdvancedSessionSettings &other)
SessionSettings(SettingChangeController *controller=NULL)
Initializes parameters with default values.
JoinRecoveryOptions::Enum joinRecovery() const
InstrumentRecoveryOptions::Enum instrumentRecovery() const
void setSessionToRecoverInstrumentsAccurately(SessionSettings &settings)
void setSessionToAccuratePreopening(SessionSettings &settings)
#define ONIXS_CMEMDH_NAMESPACE_END
Definition: Bootstrap.h:156