OnixS C++ CME Market Data Handler  5.4.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.
318  void
319  service(
320  TcpRecoveryService* service)
321  {
322  group_.
323  controlAssignment
324  (
325  "TCP Recovery Service Instance",
326  service_,
327  service
328  );
329  }
330 
331  /// Number of times a Handler must try to recover
332  /// missing data using the TCP recovery before it
333  /// switches to recover market state from snapshots
334  /// or resumes incremental data processing by natural
335  /// refresh.
336  UInt32
337  attempts() const
338  {
339  return attempts_;
340  }
341 
342  /// Updates number of times a Handler must try
343  /// to recover missing data using the TCP recovery
344  /// before it switches to recover market state from
345  /// snapshots or resumes incremental data processing
346  /// by natural refresh.
347  void
348  attempts(
349  UInt32 qty)
350  {
351  group_.
352  controlAssignment
353  (
354  "TCP Recovery Attempt Quantity",
355  attempts_,
356  qty
357  );
358  }
359 
360  /// Amount of time allocated to process a
361  /// recovery request. TCP recovery service
362  /// interrupts request processing if it can't
363  /// be accomplished within given time frame.
364  ///
365  /// Interval is measured in seconds.
366  ///
367  /// @note Default value is '10'.
368  UInt32
369  servingTimeLimit() const
370  {
371  return servingTimeLimit_;
372  }
373 
374  /// Amount of time allocated to process a
375  /// recovery request. TCP recovery service
376  /// interrupts request processing if it can't
377  /// be accomplished within given time frame.
378  ///
379  /// Interval is measured in seconds.
380  void
381  servingTimeLimit(
382  UInt32 servingTimeLimit)
383  {
384  group_.
385  controlAssignment
386  (
387  "TCP Recovery Serving Time Limit",
388  servingTimeLimit_,
389  servingTimeLimit
390  );
391  }
393  /// Re-initializes as a copy of the other one. Grouping
394  /// and value assignment control services aren't copied.
396  operator =(
397  const
399  {
400  group_.
401  controlAssignment
402  (
403  "TCP Recovery Session Settings",
404  &TcpRecoverySessionSettings::assignNoControl,
405  *this,
406  other
407  );
408 
409  return *this;
410  }
411 };
412 
413 /// Serializes market recovery option.
414 ONIXS_CMEMDH_EXPORTED
415 void
416 toStr(
417  std::string&,
418  const
420 
421 /// Serializes market recovery option.
422 inline
423 std::string
425  const
426  TcpRecoverySessionSettings& settings)
427 {
428  std::string str;
429 
430  toStr(str, settings);
431 
432  return str;
433 }
434 
435 /// Basic set of parameters affecting behavior of the
436 /// Handler when the market data processing is performed.
437 ///
438 /// @note The given class exists to provide backward compatibility
439 /// with the previous releases. Use 'AdvancedSessionSettings' instead.
441 {
442  JoinRecoveryOptions::Enum joinRecovery_;
443  GapAndErrorHandlingOptions::Enum gapAndErrorHandling_;
444 
445  InstrumentRecoveryOptions::Enum instrumentRecovery_;
446  MarketRecoveryOptions::Enum marketRecovery_;
447 
448 protected:
449  /// Instance of the group to which
450  /// the given settings belongs.
451  const
452  SettingGroup&
453  group() const
454  {
455  return *this;
456  }
457 
458  /// Re-initializes the instance as a copy of the
459  /// other one and bypassing assignment control.
460  void
462  const SessionSettings& other)
463  {
464  joinRecovery_ =
465  other.joinRecovery_;
466 
467  gapAndErrorHandling_ =
468  other.gapAndErrorHandling_;
469 
470  instrumentRecovery_ =
471  other.instrumentRecovery_;
472 
473  marketRecovery_ =
474  other.marketRecovery_;
475  }
476 
477 public:
478  /// Initializes parameters with default values.
481  controller = NULL)
482  : SettingGroup(controller)
483  , joinRecovery_(
485  InstrumentsAndMarketState)
486  , gapAndErrorHandling_(
488  RecoverMarketState)
489  , instrumentRecovery_(
491  Accurate)
492  , marketRecovery_(
494  BothMboAndMbp)
495  {
496  }
497 
498  /// Re-initializes settings as copies of
499  /// the other ones omitting group belonging.
501  const SessionSettings& other)
502  : SettingGroup()
503  , joinRecovery_(
504  other.joinRecovery_)
505  , gapAndErrorHandling_(
506  other.gapAndErrorHandling_)
507  , instrumentRecovery_(
508  other.instrumentRecovery_)
509  , marketRecovery_(
510  other.marketRecovery_)
511  {
512  }
513 
514  /// Cleans everything up.
516  {
517  }
518 
519  /// Defines aspects of recovery
520  /// to be done at market join stage.
521  ///
522  /// @note Default value is
523  /// JoinRecovery::InstrumentsAndMarket.
525  joinRecovery() const
526  {
527  return joinRecovery_;
528  }
529 
530  /// Defines aspects of recovery
531  /// to be done at market join stage.
532  void
534  JoinRecoveryOptions::Enum recovery)
535  {
536  group().
537  controlAssignment
538  (
539  "Join Recovery Strategy",
540  joinRecovery_,
541  recovery
542  );
543  }
544 
545  /// Defines what Handler should do in case
546  /// of gap in real-time (incremental) data.
547  ///
548  /// @note Default value is
549  /// GapAndErrorHandling::RecoverMarketState.
552  {
553  return gapAndErrorHandling_;
554  }
555 
556  /// Defines what Handler should do in case
557  /// of gap in real-time (incremental) data.
558  void
561  {
562  group().
563  controlAssignment
564  (
565  "Gap And Error Handling Strategy",
566  gapAndErrorHandling_,
567  handling
568  );
569  }
570 
571  /// Indicates how instrument definitions are recovered.
572  ///
573  /// @note Default value is InstrumentRecoveryOptions::Accurate.
576  {
577  return instrumentRecovery_;
578  }
579 
580  /// Defines how instrument definitions are recovered.
581  void
584  {
585  group().
586  controlAssignment
587  (
588  "Instrument Recovery Strategy",
589  instrumentRecovery_,
590  recovery
591  );
592  }
593 
594  /// Defines selected market recovery options.
595  ///
596  /// @note Default value is MarketRecovery::BothMboAndMbp.
599  {
600  return marketRecovery_;
601  }
602 
603  /// Defines market recovery options.
604  void
607  {
608  group().
609  controlAssignment
610  (
611  "Market Recovery Strategy",
612  marketRecovery_,
613  recovery
614  );
615  }
616 
617  /// Copies settings from the given instance.
618  ///
619  /// Attributes controlling value assignment aren't
620  /// cloned and thus only settings' values are copied.
622  operator =(
623  const SessionSettings& other)
624  {
625  group().
626  controlAssignment
627  (
628  "Session Settings",
629  &SessionSettings::assignNoControl,
630  *this,
631  other
632  );
633 
634  return *this;
635  }
636 };
637 
638 /// Serializes market data processing session settings.
639 ONIXS_CMEMDH_EXPORTED
640 void
641 toStr(
642  std::string&,
643  const SessionSettings&);
644 
645 /// Serializes market data processing session settings.
646 inline
647 std::string
649  const SessionSettings& settings)
650 {
651  std::string str;
652 
653  toStr(str, settings);
654 
655  return str;
656 }
657 
658 /// Full set of parameters affecting behavior
659 /// of the Handler when market data is processed.
662  : public SessionSettings
663 {
664  // Lets grouping and value assignment control functioning.
666 
667  TcpRecoverySessionSettings tcpRecovery_;
668 
669  // Re-initializes the instance as a copy of the
670  // other one and bypassing assignment control.
671  void
672  assignNoControl(
673  const AdvancedSessionSettings& other)
674  {
675  SessionSettings::assignNoControl(other);
676 
677  tcpRecovery_.assignNoControl(other.tcpRecovery_);
678  }
679 
680 public:
681  /// Initializes parameters with default values.
684  controller = NULL)
685  : SessionSettings(controller)
686  , tcpRecovery_(&group())
687  {
688  }
689 
690  /// Re-initializes settings as copies of
691  /// the other ones omitting group belonging.
693  const AdvancedSessionSettings& other)
694  : SessionSettings(
695  static_cast
696  <const SessionSettings&>
697  (other))
698  , tcpRecovery_(
699  other.tcpRecovery_)
700  {
701  }
702 
703  /// Cleans everything up.
705  {
706  }
707 
708  /// Set of TCP recovery settings.
709  const
711  tcpRecovery() const
712  {
713  return tcpRecovery_;
714  }
715 
716  /// Editable set of TCP recovery settings.
719  {
720  return tcpRecovery_;
721  }
722 
723  /// Copies settings from the given instance.
724  ///
725  /// Attributes controlling value assignment aren't
726  /// cloned and thus only settings' values are copied.
728  operator =(
729  const AdvancedSessionSettings& other)
730  {
731  group().
732  controlAssignment
733  (
734  "Advanced Session Settings",
735  &AdvancedSessionSettings::assignNoControl,
736  *this,
737  other
738  );
739 
740  return *this;
741  }
742 };
743 
744 /// Serializes market data processing session settings.
745 ONIXS_CMEMDH_EXPORTED
746 void
747 toStr(
748  std::string&,
749  const AdvancedSessionSettings&);
750 
751 /// Serializes market data processing session settings.
752 inline
753 std::string
755  const
756  AdvancedSessionSettings& settings)
757 {
758  std::string str;
759 
760  toStr(str, settings);
761 
762  return str;
763 }
764 
765 // Various functions helping in configuring session in the desired way.
766 
767 /// Updates session settings to tell the Handler
768 /// to recover instruments using accurate strategy
769 /// each time instrument recovery is performed.
770 inline
771 void
773 (
774  SessionSettings& settings
775 )
776 {
777  settings.
778  instrumentRecovery(
780  Accurate);
781 }
782 
783 /// Updates session settings to tell the Handler
784 /// to recover instruments using fast strategy each
785 /// time instrument recovery is performed.
786 inline
787 void
789 (
790  SessionSettings& settings
791 )
792 {
793  settings.
794  instrumentRecovery(
796  Fast);
797 }
798 
799 /// Updates session settings to tell the Handler
800 /// to skip join-time recovery and switch processing
801 /// incremental (real-time) data.
802 inline
803 void
805 (
806  SessionSettings& settings
807 )
808 {
809  settings.
810  joinRecovery(
812  Disabled);
813 }
814 
815 /// Updates session settings to tell the Handler
816 /// to recover instruments and market state before
817 /// it switches processing incremental data.
818 inline
819 void
821  SessionSettings& settings)
822 {
823  settings.
824  joinRecovery(
826  InstrumentsAndMarketState);
827 }
828 
829 
830 /// Updates session settings to recover
831 /// books of all types each time the Handler
832 /// recovers market state from snapshots.
833 inline
834 void
836 (
837  SessionSettings& settings
838 )
839 {
840  settings.
841  marketRecovery(
843  BothMboAndMbp);
844 }
845 
846 /// Updates session settings to recover
847 /// MBO books only each time the Handler
848 /// recovers market state from snapshots.
849 inline
850 void
852 (
853  SessionSettings& settings
854 )
855 {
856  settings.
857  marketRecovery(
859  MboOnly);
860 }
861 
862 /// Updates session settings to recover
863 /// MBP books only each time the Handler
864 /// recovers market state from snapshots.
865 inline
866 void
868 (
869  SessionSettings& settings
870 )
871 {
872  settings.
873  marketRecovery(
875  MbpOnly);
876 }
877 
878 /// Updates session settings to tell the
879 /// Handler to recover instruments and market
880 /// state (books) in case of gap or other issue.
881 inline
882 void
884 (
885  SessionSettings& settings
886 )
887 {
888  settings.
889  gapAndErrorHandling(
891  RecoverInstrumentsAndMarketState);
892 }
893 
894 /// Updates session settings to tell the
895 /// Handler to recover market state (books)
896 /// in case of gap or other issue.
897 inline
898 void
900 (
901  SessionSettings& settings
902 )
903 {
904  settings.
905  gapAndErrorHandling(
907  RecoverMarketState);
908 }
909 
910 /// Updates session settings to tell the Handler
911 /// continue processing incremental (real-time)
912 /// data in case of gap or other issue.
913 inline
914 void
916 (
917  SessionSettings& settings
918 )
919 {
920  settings.
921  gapAndErrorHandling(
923  ContinueProcessing);
924 }
925 
926 // Complex (one-call) setup.
927 
928 /// Configures session to maintain order books
929 /// accurately and without performing initial
930 /// (late-join) recovery thus considering market
931 /// data processing is started from the beginning
932 /// of weekly session.
933 inline
934 void
936 (
937  SessionSettings& settings
938 )
939 {
941  (
942  settings
943  );
945  (
946  settings
947  );
949  (
950  settings
951  );
953  (
954  settings
955  );
956 }
957 
958 /// Configures session to maintain order
959 /// books accurately and considering market
960 /// data processing is started at the middle
961 /// of weekly session (late join).
962 inline
963 void
965 (
966  SessionSettings& settings
967 )
968 {
970  (
971  settings
972  );
974  (
975  settings
976  );
978  (
979  settings
980  );
982  (
983  settings
984  );
985 }
986 
987 /// Configures session settings to maintain
988 /// order books using natural refresh. Startup
989 /// recovery is not performed and thus only
990 /// real-time processing takes place.
991 inline
992 void
994  SessionSettings& settings)
995 {
997  (
998  settings
999  );
1001  (
1002  settings
1003  );
1004 }
1005 
1006 // Deprecated way of session setup.
1007 
1008 #if !defined (ONIXS_CMEMDH_NO_DEPRECATED)
1009 
1010 /// Settings for session with accurate book
1011 /// maintenance and considering market data
1012 /// processing is started from the beginning
1013 /// of weekly session.
1017 {
1018  /// Configures session settings
1019  /// according to specialization.
1021  {
1023  }
1024 };
1025 
1026 /// Settings for session with accurate book maintenance
1027 /// and considering market data processing is started
1028 /// from the beginning of weekly session. Market recovery
1029 /// is limited to recovery market by order books only.
1033 {
1034  /// Configures session settings
1035  /// according to specialization.
1037  {
1040  }
1041 };
1042 
1043 /// Settings for session with accurate book maintenance
1044 /// and considering market data processing is started
1045 /// from the beginning of weekly session. Market recovery
1046 /// is limited to recovery market by price books only.
1050 {
1051  /// Configures session settings
1052  /// according to specialization.
1054  {
1057  }
1058 };
1059 
1060 /// Settings for session with accurate book
1061 /// maintenance and considering market data
1062 /// processing is started at the middle of
1063 /// weekly session (late join).
1067 {
1068  /// Configures session settings
1069  /// according to specialization.
1071  : SessionSettings()
1072  {
1074  }
1075 };
1076 
1077 /// Settings for session with accurate book maintenance
1078 /// and considering market data processing is started at
1079 /// the middle of weekly session (late join). Market recovery
1080 /// is limited to recover market by order books only.
1084 {
1085  /// Configures session settings
1086  /// according to specialization.
1088  {
1091  }
1092 };
1093 
1094 /// Settings for session with accurate book maintenance
1095 /// and considering market data processing is started at
1096 /// the middle of weekly session (late join). Market recovery
1097 /// is limited to recover market by price books only.
1101 {
1102  /// Configures session settings
1103  /// according to specialization.
1105  {
1108  }
1109 };
1110 
1111 /// Configures session settings to maintain
1112 /// order books using natural refresh. Startup
1113 /// recovery is not performed and thus only
1114 /// real-time processing takes place.
1118 {
1119  /// Configures session settings
1120  /// according to specialization.
1122  : SessionSettings()
1123  {
1125  }
1126 };
1127 
1128 #endif // ONIXS_CMEMDH_NO_DEPRECATED
1129 
#define ONIXS_CMEMDH_LTWT_CLASS
Definition: Bootstrap.h:94
void joinRecovery(JoinRecoveryOptions::Enum recovery)
void setSessionToRecoverInstrumentsFast(SessionSettings &settings)
Handler&#39;s configuration settings.
void setSessionToRecoverBothMboAndMbpBooks(SessionSettings &settings)
void setSessionToRecoverBooksUponRealtimeIssues(SessionSettings &settings)
Collection of session settings related to TCP recovery.
void marketRecovery(MarketRecoveryOptions::Enum recovery)
Defines market recovery options.
UInt32 UInt32
uInt32.
Definition: Fields.h:247
void setSessionToRecoverMbpBooksOnly(SessionSettings &settings)
void assignNoControl(const SessionSettings &other)
void setSessionToLateJoin(SessionSettings &settings)
void instrumentRecovery(InstrumentRecoveryOptions::Enum recovery)
Defines how instrument definitions are recovered.
Handler recovers market state from snapshots.
AdvancedSessionSettings(SettingAssignController *controller=NULL)
Initializes parameters with default values.
~SessionSettings()
Cleans everything up.
#define ONIXS_CMEMDH_EXPORTED_CLASS_DECL(typeName)
Definition: Bootstrap.h:46
void setSessionToJoinInPreopening(SessionSettings &settings)
#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:123
std::string toStr(const AdvancedSessionSettings &settings)
Serializes market data processing session settings.
Defines different ways of instrument definition recovery.
const SettingGroup & group() const
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
void gapAndErrorHandling(GapAndErrorHandlingOptions::Enum handling)
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)
JoinRecoveryOptions::Enum joinRecovery() const
InstrumentRecoveryOptions::Enum instrumentRecovery() const
SessionSettings(SettingAssignController *controller=NULL)
Initializes parameters with default values.
void setSessionToRecoverInstrumentsAccurately(SessionSettings &settings)
void setSessionToAccuratePreopening(SessionSettings &settings)
#define ONIXS_CMEMDH_NAMESPACE_END
Definition: Bootstrap.h:156