OnixS C++ CME MDP Premium Market Data Handler  5.9.0
API Documentation
Messages.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 <OnixS/CME/MDH/Messages.h>
24 #include <OnixS/CME/MDH/FIX/Message.h>
25 
26 namespace Base = OnixS::CME::MDH;
27 
28 ONIXS_CMEMDHFIX_NAMESPACE_BEGIN
29 
30 class ONIXS_CMEMDH_LTWT ChannelReset4 : public Message
31 {
32  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
33  {
34  StrRef type() const ONIXS_CMEMDH_OVERRIDE
35  {
36  return Binary::fixType();
37  }
38 
39  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
40 
41  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
42 
43  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
44 
45  static const MessageAccessor& self()
46  {
47  static const Accessor self_;
48  return self_;
49  }
50  };
51 
52 public:
53  typedef Base::ChannelReset4 Binary;
54 
55  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
56 
57  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
58  {
59  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
60 
61  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
62  {
63  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
64 
65  static const GroupEntryAccessor& self()
66  {
67  static const Accessor self_;
68  return self_;
69  }
70  };
71 
72  public:
73  typedef Binary::Entry BinaryEntry;
74 
75  Entry(const BinaryEntry& entry)
76  : GroupEntry(entry, Accessor::self())
77  {
78  }
79  };
80 
81  struct ONIXS_CMEMDH_LTWT Entries : Group
82  {
83  typedef Binary::Entries BinaryEntries;
84 
85  Entries(const BinaryEntries& group)
86  : Group(group.entries(), Entry::Accessor::self())
87  {
88  }
89  };
90 
91  ChannelReset4(const Binary& message)
92  : Message(message, Accessor::self())
93  {
94  }
95 };
96 
97 class ONIXS_CMEMDH_LTWT AdminHeartbeat12 : public Message
98 {
99  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
100  {
101  StrRef type() const ONIXS_CMEMDH_OVERRIDE
102  {
103  return Binary::fixType();
104  }
105 
106  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
107 
108  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
109 
110  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
111 
112  static const MessageAccessor& self()
113  {
114  static const Accessor self_;
115  return self_;
116  }
117  };
118 
119 public:
120  typedef Base::AdminHeartbeat12 Binary;
121 
122  AdminHeartbeat12(const Binary& message)
123  : Message(message, Accessor::self())
124  {
125  }
126 };
127 
128 class ONIXS_CMEMDH_LTWT AdminLogin15 : public Message
129 {
130  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
131  {
132  StrRef type() const ONIXS_CMEMDH_OVERRIDE
133  {
134  return Binary::fixType();
135  }
136 
137  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
138 
139  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
140 
141  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
142 
143  static const MessageAccessor& self()
144  {
145  static const Accessor self_;
146  return self_;
147  }
148  };
149 
150 public:
151  typedef Base::AdminLogin15 Binary;
152 
153  AdminLogin15(const Binary& message)
154  : Message(message, Accessor::self())
155  {
156  }
157 };
158 
159 class ONIXS_CMEMDH_LTWT AdminLogout16 : public Message
160 {
161  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
162  {
163  StrRef type() const ONIXS_CMEMDH_OVERRIDE
164  {
165  return Binary::fixType();
166  }
167 
168  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
169 
170  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
171 
172  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
173 
174  static const MessageAccessor& self()
175  {
176  static const Accessor self_;
177  return self_;
178  }
179  };
180 
181 public:
182  typedef Base::AdminLogout16 Binary;
183 
184  AdminLogout16(const Binary& message)
185  : Message(message, Accessor::self())
186  {
187  }
188 };
189 
190 class ONIXS_CMEMDH_LTWT SecurityStatus30 : public Message
191 {
192  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
193  {
194  StrRef type() const ONIXS_CMEMDH_OVERRIDE
195  {
196  return Binary::fixType();
197  }
198 
199  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
200 
201  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
202 
203  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
204 
205  static const MessageAccessor& self()
206  {
207  static const Accessor self_;
208  return self_;
209  }
210  };
211 
212 public:
213  typedef Base::SecurityStatus30 Binary;
214 
215  SecurityStatus30(const Binary& message)
216  : Message(message, Accessor::self())
217  {
218  }
219 };
220 
221 class ONIXS_CMEMDH_LTWT IncrementalRefreshVolume37 : public Message
222 {
223  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
224  {
225  StrRef type() const ONIXS_CMEMDH_OVERRIDE
226  {
227  return Binary::fixType();
228  }
229 
230  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
231 
232  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
233 
234  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
235 
236  static const MessageAccessor& self()
237  {
238  static const Accessor self_;
239  return self_;
240  }
241  };
242 
243 public:
244  typedef Base::IncrementalRefreshVolume37 Binary;
245 
246  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
247 
248  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
249  {
250  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
251 
252  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
253  {
254  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
255 
256  static const GroupEntryAccessor& self()
257  {
258  static const Accessor self_;
259  return self_;
260  }
261  };
262 
263  public:
264  typedef Binary::Entry BinaryEntry;
265 
266  Entry(const BinaryEntry& entry)
267  : GroupEntry(entry, Accessor::self())
268  {
269  }
270  };
271 
272  struct ONIXS_CMEMDH_LTWT Entries : Group
273  {
274  typedef Binary::Entries BinaryEntries;
275 
276  Entries(const BinaryEntries& group)
277  : Group(group.entries(), Entry::Accessor::self())
278  {
279  }
280  };
281 
282  IncrementalRefreshVolume37(const Binary& message)
283  : Message(message, Accessor::self())
284  {
285  }
286 };
287 
288 class ONIXS_CMEMDH_LTWT QuoteRequest39 : public Message
289 {
290  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
291  {
292  StrRef type() const ONIXS_CMEMDH_OVERRIDE
293  {
294  return Binary::fixType();
295  }
296 
297  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
298 
299  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
300 
301  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
302 
303  static const MessageAccessor& self()
304  {
305  static const Accessor self_;
306  return self_;
307  }
308  };
309 
310 public:
311  typedef Base::QuoteRequest39 Binary;
312 
313  ONIXS_CMEMDH_LTWT_STRUCT_DECL(RelatedSym);
314 
315  class ONIXS_CMEMDH_LTWT RelatedSymEntry : public GroupEntry
316  {
317  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(RelatedSym);
318 
319  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
320  {
321  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
322 
323  static const GroupEntryAccessor& self()
324  {
325  static const Accessor self_;
326  return self_;
327  }
328  };
329 
330  public:
331  typedef Binary::RelatedSymEntry BinaryEntry;
332 
333  RelatedSymEntry(const BinaryEntry& entry)
334  : GroupEntry(entry, Accessor::self())
335  {
336  }
337  };
338 
339  struct ONIXS_CMEMDH_LTWT RelatedSym : Group
340  {
341  typedef Binary::RelatedSym BinaryEntries;
342 
343  RelatedSym(const BinaryEntries& group)
344  : Group(group.entries(), RelatedSymEntry::Accessor::self())
345  {
346  }
347  };
348 
349  QuoteRequest39(const Binary& message)
350  : Message(message, Accessor::self())
351  {
352  }
353 };
354 
355 class ONIXS_CMEMDH_LTWT IncrementalRefreshBook46 : public Message
356 {
357  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
358  {
359  StrRef type() const ONIXS_CMEMDH_OVERRIDE
360  {
361  return Binary::fixType();
362  }
363 
364  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
365 
366  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
367 
368  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
369 
370  static const MessageAccessor& self()
371  {
372  static const Accessor self_;
373  return self_;
374  }
375  };
376 
377 public:
378  typedef Base::IncrementalRefreshBook46 Binary;
379 
380  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
381 
382  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
383  {
384  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
385 
386  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
387  {
388  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
389 
390  static const GroupEntryAccessor& self()
391  {
392  static const Accessor self_;
393  return self_;
394  }
395  };
396 
397  public:
398  typedef Binary::Entry BinaryEntry;
399 
400  Entry(const BinaryEntry& entry)
401  : GroupEntry(entry, Accessor::self())
402  {
403  }
404  };
405 
406  struct ONIXS_CMEMDH_LTWT Entries : Group
407  {
408  typedef Binary::Entries BinaryEntries;
409 
410  Entries(const BinaryEntries& group)
411  : Group(group.entries(), Entry::Accessor::self())
412  {
413  }
414  };
415 
416  ONIXS_CMEMDH_LTWT_STRUCT_DECL(OrderIDEntries);
417 
418  class ONIXS_CMEMDH_LTWT OrderIDEntry : public GroupEntry
419  {
420  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(OrderIDEntries);
421 
422  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
423  {
424  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
425 
426  static const GroupEntryAccessor& self()
427  {
428  static const Accessor self_;
429  return self_;
430  }
431  };
432 
433  public:
434  typedef Binary::OrderIDEntry BinaryEntry;
435 
436  OrderIDEntry(const BinaryEntry& entry)
437  : GroupEntry(entry, Accessor::self())
438  {
439  }
440  };
441 
442  struct ONIXS_CMEMDH_LTWT OrderIDEntries : Group
443  {
444  typedef Binary::OrderIDEntries BinaryEntries;
445 
446  OrderIDEntries(const BinaryEntries& group)
447  : Group(group.entries(), OrderIDEntry::Accessor::self())
448  {
449  }
450  };
451 
452  IncrementalRefreshBook46(const Binary& message)
453  : Message(message, Accessor::self())
454  {
455  }
456 };
457 
458 class ONIXS_CMEMDH_LTWT IncrementalRefreshOrderBook47 : public Message
459 {
460  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
461  {
462  StrRef type() const ONIXS_CMEMDH_OVERRIDE
463  {
464  return Binary::fixType();
465  }
466 
467  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
468 
469  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
470 
471  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
472 
473  static const MessageAccessor& self()
474  {
475  static const Accessor self_;
476  return self_;
477  }
478  };
479 
480 public:
481  typedef Base::IncrementalRefreshOrderBook47 Binary;
482 
483  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
484 
485  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
486  {
487  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
488 
489  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
490  {
491  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
492 
493  static const GroupEntryAccessor& self()
494  {
495  static const Accessor self_;
496  return self_;
497  }
498  };
499 
500  public:
501  typedef Binary::Entry BinaryEntry;
502 
503  Entry(const BinaryEntry& entry)
504  : GroupEntry(entry, Accessor::self())
505  {
506  }
507  };
508 
509  struct ONIXS_CMEMDH_LTWT Entries : Group
510  {
511  typedef Binary::Entries BinaryEntries;
512 
513  Entries(const BinaryEntries& group)
514  : Group(group.entries(), Entry::Accessor::self())
515  {
516  }
517  };
518 
519  IncrementalRefreshOrderBook47(const Binary& message)
520  : Message(message, Accessor::self())
521  {
522  }
523 };
524 
525 class ONIXS_CMEMDH_LTWT IncrementalRefreshTradeSummary48 : public Message
526 {
527  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
528  {
529  StrRef type() const ONIXS_CMEMDH_OVERRIDE
530  {
531  return Binary::fixType();
532  }
533 
534  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
535 
536  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
537 
538  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
539 
540  static const MessageAccessor& self()
541  {
542  static const Accessor self_;
543  return self_;
544  }
545  };
546 
547 public:
548  typedef Base::IncrementalRefreshTradeSummary48 Binary;
549 
550  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
551 
552  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
553  {
554  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
555 
556  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
557  {
558  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
559 
560  static const GroupEntryAccessor& self()
561  {
562  static const Accessor self_;
563  return self_;
564  }
565  };
566 
567  public:
568  typedef Binary::Entry BinaryEntry;
569 
570  Entry(const BinaryEntry& entry)
571  : GroupEntry(entry, Accessor::self())
572  {
573  }
574  };
575 
576  struct ONIXS_CMEMDH_LTWT Entries : Group
577  {
578  typedef Binary::Entries BinaryEntries;
579 
580  Entries(const BinaryEntries& group)
581  : Group(group.entries(), Entry::Accessor::self())
582  {
583  }
584  };
585 
586  ONIXS_CMEMDH_LTWT_STRUCT_DECL(OrderIDEntries);
587 
588  class ONIXS_CMEMDH_LTWT OrderIDEntry : public GroupEntry
589  {
590  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(OrderIDEntries);
591 
592  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
593  {
594  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
595 
596  static const GroupEntryAccessor& self()
597  {
598  static const Accessor self_;
599  return self_;
600  }
601  };
602 
603  public:
604  typedef Binary::OrderIDEntry BinaryEntry;
605 
606  OrderIDEntry(const BinaryEntry& entry)
607  : GroupEntry(entry, Accessor::self())
608  {
609  }
610  };
611 
612  struct ONIXS_CMEMDH_LTWT OrderIDEntries : Group
613  {
614  typedef Binary::OrderIDEntries BinaryEntries;
615 
616  OrderIDEntries(const BinaryEntries& group)
617  : Group(group.entries(), OrderIDEntry::Accessor::self())
618  {
619  }
620  };
621 
622  IncrementalRefreshTradeSummary48(const Binary& message)
623  : Message(message, Accessor::self())
624  {
625  }
626 };
627 
628 class ONIXS_CMEMDH_LTWT IncrementalRefreshDailyStatistics49 : public Message
629 {
630  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
631  {
632  StrRef type() const ONIXS_CMEMDH_OVERRIDE
633  {
634  return Binary::fixType();
635  }
636 
637  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
638 
639  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
640 
641  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
642 
643  static const MessageAccessor& self()
644  {
645  static const Accessor self_;
646  return self_;
647  }
648  };
649 
650 public:
651  typedef Base::IncrementalRefreshDailyStatistics49 Binary;
652 
653  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
654 
655  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
656  {
657  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
658 
659  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
660  {
661  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
662 
663  static const GroupEntryAccessor& self()
664  {
665  static const Accessor self_;
666  return self_;
667  }
668  };
669 
670  public:
671  typedef Binary::Entry BinaryEntry;
672 
673  Entry(const BinaryEntry& entry)
674  : GroupEntry(entry, Accessor::self())
675  {
676  }
677  };
678 
679  struct ONIXS_CMEMDH_LTWT Entries : Group
680  {
681  typedef Binary::Entries BinaryEntries;
682 
683  Entries(const BinaryEntries& group)
684  : Group(group.entries(), Entry::Accessor::self())
685  {
686  }
687  };
688 
689  IncrementalRefreshDailyStatistics49(const Binary& message)
690  : Message(message, Accessor::self())
691  {
692  }
693 };
694 
695 class ONIXS_CMEMDH_LTWT IncrementalRefreshLimitsBanding50 : public Message
696 {
697  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
698  {
699  StrRef type() const ONIXS_CMEMDH_OVERRIDE
700  {
701  return Binary::fixType();
702  }
703 
704  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
705 
706  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
707 
708  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
709 
710  static const MessageAccessor& self()
711  {
712  static const Accessor self_;
713  return self_;
714  }
715  };
716 
717 public:
718  typedef Base::IncrementalRefreshLimitsBanding50 Binary;
719 
720  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
721 
722  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
723  {
724  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
725 
726  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
727  {
728  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
729 
730  static const GroupEntryAccessor& self()
731  {
732  static const Accessor self_;
733  return self_;
734  }
735  };
736 
737  public:
738  typedef Binary::Entry BinaryEntry;
739 
740  Entry(const BinaryEntry& entry)
741  : GroupEntry(entry, Accessor::self())
742  {
743  }
744  };
745 
746  struct ONIXS_CMEMDH_LTWT Entries : Group
747  {
748  typedef Binary::Entries BinaryEntries;
749 
750  Entries(const BinaryEntries& group)
751  : Group(group.entries(), Entry::Accessor::self())
752  {
753  }
754  };
755 
756  IncrementalRefreshLimitsBanding50(const Binary& message)
757  : Message(message, Accessor::self())
758  {
759  }
760 };
761 
762 class ONIXS_CMEMDH_LTWT IncrementalRefreshSessionStatistics51 : public Message
763 {
764  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
765  {
766  StrRef type() const ONIXS_CMEMDH_OVERRIDE
767  {
768  return Binary::fixType();
769  }
770 
771  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
772 
773  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
774 
775  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
776 
777  static const MessageAccessor& self()
778  {
779  static const Accessor self_;
780  return self_;
781  }
782  };
783 
784 public:
785  typedef Base::IncrementalRefreshSessionStatistics51 Binary;
786 
787  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
788 
789  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
790  {
791  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
792 
793  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
794  {
795  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
796 
797  static const GroupEntryAccessor& self()
798  {
799  static const Accessor self_;
800  return self_;
801  }
802  };
803 
804  public:
805  typedef Binary::Entry BinaryEntry;
806 
807  Entry(const BinaryEntry& entry)
808  : GroupEntry(entry, Accessor::self())
809  {
810  }
811  };
812 
813  struct ONIXS_CMEMDH_LTWT Entries : Group
814  {
815  typedef Binary::Entries BinaryEntries;
816 
817  Entries(const BinaryEntries& group)
818  : Group(group.entries(), Entry::Accessor::self())
819  {
820  }
821  };
822 
823  IncrementalRefreshSessionStatistics51(const Binary& message)
824  : Message(message, Accessor::self())
825  {
826  }
827 };
828 
829 class ONIXS_CMEMDH_LTWT SnapshotFullRefresh52 : public Message
830 {
831  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
832  {
833  StrRef type() const ONIXS_CMEMDH_OVERRIDE
834  {
835  return Binary::fixType();
836  }
837 
838  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
839 
840  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
841 
842  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
843 
844  static const MessageAccessor& self()
845  {
846  static const Accessor self_;
847  return self_;
848  }
849  };
850 
851 public:
852  typedef Base::SnapshotFullRefresh52 Binary;
853 
854  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
855 
856  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
857  {
858  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
859 
860  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
861  {
862  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
863 
864  static const GroupEntryAccessor& self()
865  {
866  static const Accessor self_;
867  return self_;
868  }
869  };
870 
871  public:
872  typedef Binary::Entry BinaryEntry;
873 
874  Entry(const BinaryEntry& entry)
875  : GroupEntry(entry, Accessor::self())
876  {
877  }
878  };
879 
880  struct ONIXS_CMEMDH_LTWT Entries : Group
881  {
882  typedef Binary::Entries BinaryEntries;
883 
884  Entries(const BinaryEntries& group)
885  : Group(group.entries(), Entry::Accessor::self())
886  {
887  }
888  };
889 
890  SnapshotFullRefresh52(const Binary& message)
891  : Message(message, Accessor::self())
892  {
893  }
894 };
895 
896 class ONIXS_CMEMDH_LTWT SnapshotFullRefreshOrderBook53 : public Message
897 {
898  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
899  {
900  StrRef type() const ONIXS_CMEMDH_OVERRIDE
901  {
902  return Binary::fixType();
903  }
904 
905  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
906 
907  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
908 
909  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
910 
911  static const MessageAccessor& self()
912  {
913  static const Accessor self_;
914  return self_;
915  }
916  };
917 
918 public:
919  typedef Base::SnapshotFullRefreshOrderBook53 Binary;
920 
921  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
922 
923  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
924  {
925  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
926 
927  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
928  {
929  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
930 
931  static const GroupEntryAccessor& self()
932  {
933  static const Accessor self_;
934  return self_;
935  }
936  };
937 
938  public:
939  typedef Binary::Entry BinaryEntry;
940 
941  Entry(const BinaryEntry& entry)
942  : GroupEntry(entry, Accessor::self())
943  {
944  }
945  };
946 
947  struct ONIXS_CMEMDH_LTWT Entries : Group
948  {
949  typedef Binary::Entries BinaryEntries;
950 
951  Entries(const BinaryEntries& group)
952  : Group(group.entries(), Entry::Accessor::self())
953  {
954  }
955  };
956 
957  SnapshotFullRefreshOrderBook53(const Binary& message)
958  : Message(message, Accessor::self())
959  {
960  }
961 };
962 
963 class ONIXS_CMEMDH_LTWT InstrumentDefinitionFuture54 : public Message
964 {
965  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
966  {
967  StrRef type() const ONIXS_CMEMDH_OVERRIDE
968  {
969  return Binary::fixType();
970  }
971 
972  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
973 
974  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
975 
976  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
977 
978  static const MessageAccessor& self()
979  {
980  static const Accessor self_;
981  return self_;
982  }
983  };
984 
985 public:
986  typedef Base::InstrumentDefinitionFuture54 Binary;
987 
988  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
989 
990  class ONIXS_CMEMDH_LTWT EventsEntry : public GroupEntry
991  {
992  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
993 
994  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
995  {
996  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
997 
998  static const GroupEntryAccessor& self()
999  {
1000  static const Accessor self_;
1001  return self_;
1002  }
1003  };
1004 
1005  public:
1006  typedef Binary::EventsEntry BinaryEntry;
1007 
1008  EventsEntry(const BinaryEntry& entry)
1009  : GroupEntry(entry, Accessor::self())
1010  {
1011  }
1012  };
1013 
1014  struct ONIXS_CMEMDH_LTWT Events : Group
1015  {
1016  typedef Binary::Events BinaryEntries;
1017 
1018  Events(const BinaryEntries& group)
1019  : Group(group.entries(), EventsEntry::Accessor::self())
1020  {
1021  }
1022  };
1023 
1024  ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1025 
1026  class ONIXS_CMEMDH_LTWT FeedTypesEntry : public GroupEntry
1027  {
1028  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1029 
1030  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1031  {
1032  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1033 
1034  static const GroupEntryAccessor& self()
1035  {
1036  static const Accessor self_;
1037  return self_;
1038  }
1039  };
1040 
1041  public:
1042  typedef Binary::FeedTypesEntry BinaryEntry;
1043 
1044  FeedTypesEntry(const BinaryEntry& entry)
1045  : GroupEntry(entry, Accessor::self())
1046  {
1047  }
1048  };
1049 
1050  struct ONIXS_CMEMDH_LTWT FeedTypes : Group
1051  {
1052  typedef Binary::FeedTypes BinaryEntries;
1053 
1054  FeedTypes(const BinaryEntries& group)
1055  : Group(group.entries(), FeedTypesEntry::Accessor::self())
1056  {
1057  }
1058  };
1059 
1060  ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1061 
1062  class ONIXS_CMEMDH_LTWT InstAttribEntry : public GroupEntry
1063  {
1064  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1065 
1066  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1067  {
1068  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1069 
1070  static const GroupEntryAccessor& self()
1071  {
1072  static const Accessor self_;
1073  return self_;
1074  }
1075  };
1076 
1077  public:
1078  typedef Binary::InstAttribEntry BinaryEntry;
1079 
1080  InstAttribEntry(const BinaryEntry& entry)
1081  : GroupEntry(entry, Accessor::self())
1082  {
1083  }
1084  };
1085 
1086  struct ONIXS_CMEMDH_LTWT InstAttrib : Group
1087  {
1088  typedef Binary::InstAttrib BinaryEntries;
1089 
1090  InstAttrib(const BinaryEntries& group)
1091  : Group(group.entries(), InstAttribEntry::Accessor::self())
1092  {
1093  }
1094  };
1095 
1096  ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1097 
1098  class ONIXS_CMEMDH_LTWT LotTypeRulesEntry : public GroupEntry
1099  {
1100  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1101 
1102  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1103  {
1104  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1105 
1106  static const GroupEntryAccessor& self()
1107  {
1108  static const Accessor self_;
1109  return self_;
1110  }
1111  };
1112 
1113  public:
1114  typedef Binary::LotTypeRulesEntry BinaryEntry;
1115 
1116  LotTypeRulesEntry(const BinaryEntry& entry)
1117  : GroupEntry(entry, Accessor::self())
1118  {
1119  }
1120  };
1121 
1122  struct ONIXS_CMEMDH_LTWT LotTypeRules : Group
1123  {
1124  typedef Binary::LotTypeRules BinaryEntries;
1125 
1126  LotTypeRules(const BinaryEntries& group)
1127  : Group(group.entries(), LotTypeRulesEntry::Accessor::self())
1128  {
1129  }
1130  };
1131 
1132  InstrumentDefinitionFuture54(const Binary& message)
1133  : Message(message, Accessor::self())
1134  {
1135  }
1136 };
1137 
1138 class ONIXS_CMEMDH_LTWT InstrumentDefinitionOption55 : public Message
1139 {
1140  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
1141  {
1142  StrRef type() const ONIXS_CMEMDH_OVERRIDE
1143  {
1144  return Binary::fixType();
1145  }
1146 
1147  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1148 
1149  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1150 
1151  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
1152 
1153  static const MessageAccessor& self()
1154  {
1155  static const Accessor self_;
1156  return self_;
1157  }
1158  };
1159 
1160 public:
1161  typedef Base::InstrumentDefinitionOption55 Binary;
1162 
1163  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
1164 
1165  class ONIXS_CMEMDH_LTWT EventsEntry : public GroupEntry
1166  {
1167  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
1168 
1169  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1170  {
1171  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1172 
1173  static const GroupEntryAccessor& self()
1174  {
1175  static const Accessor self_;
1176  return self_;
1177  }
1178  };
1179 
1180  public:
1181  typedef Binary::EventsEntry BinaryEntry;
1182 
1183  EventsEntry(const BinaryEntry& entry)
1184  : GroupEntry(entry, Accessor::self())
1185  {
1186  }
1187  };
1188 
1189  struct ONIXS_CMEMDH_LTWT Events : Group
1190  {
1191  typedef Binary::Events BinaryEntries;
1192 
1193  Events(const BinaryEntries& group)
1194  : Group(group.entries(), EventsEntry::Accessor::self())
1195  {
1196  }
1197  };
1198 
1199  ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1200 
1201  class ONIXS_CMEMDH_LTWT FeedTypesEntry : public GroupEntry
1202  {
1203  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1204 
1205  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1206  {
1207  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1208 
1209  static const GroupEntryAccessor& self()
1210  {
1211  static const Accessor self_;
1212  return self_;
1213  }
1214  };
1215 
1216  public:
1217  typedef Binary::FeedTypesEntry BinaryEntry;
1218 
1219  FeedTypesEntry(const BinaryEntry& entry)
1220  : GroupEntry(entry, Accessor::self())
1221  {
1222  }
1223  };
1224 
1225  struct ONIXS_CMEMDH_LTWT FeedTypes : Group
1226  {
1227  typedef Binary::FeedTypes BinaryEntries;
1228 
1229  FeedTypes(const BinaryEntries& group)
1230  : Group(group.entries(), FeedTypesEntry::Accessor::self())
1231  {
1232  }
1233  };
1234 
1235  ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1236 
1237  class ONIXS_CMEMDH_LTWT InstAttribEntry : public GroupEntry
1238  {
1239  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1240 
1241  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1242  {
1243  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1244 
1245  static const GroupEntryAccessor& self()
1246  {
1247  static const Accessor self_;
1248  return self_;
1249  }
1250  };
1251 
1252  public:
1253  typedef Binary::InstAttribEntry BinaryEntry;
1254 
1255  InstAttribEntry(const BinaryEntry& entry)
1256  : GroupEntry(entry, Accessor::self())
1257  {
1258  }
1259  };
1260 
1261  struct ONIXS_CMEMDH_LTWT InstAttrib : Group
1262  {
1263  typedef Binary::InstAttrib BinaryEntries;
1264 
1265  InstAttrib(const BinaryEntries& group)
1266  : Group(group.entries(), InstAttribEntry::Accessor::self())
1267  {
1268  }
1269  };
1270 
1271  ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1272 
1273  class ONIXS_CMEMDH_LTWT LotTypeRulesEntry : public GroupEntry
1274  {
1275  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1276 
1277  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1278  {
1279  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1280 
1281  static const GroupEntryAccessor& self()
1282  {
1283  static const Accessor self_;
1284  return self_;
1285  }
1286  };
1287 
1288  public:
1289  typedef Binary::LotTypeRulesEntry BinaryEntry;
1290 
1291  LotTypeRulesEntry(const BinaryEntry& entry)
1292  : GroupEntry(entry, Accessor::self())
1293  {
1294  }
1295  };
1296 
1297  struct ONIXS_CMEMDH_LTWT LotTypeRules : Group
1298  {
1299  typedef Binary::LotTypeRules BinaryEntries;
1300 
1301  LotTypeRules(const BinaryEntries& group)
1302  : Group(group.entries(), LotTypeRulesEntry::Accessor::self())
1303  {
1304  }
1305  };
1306 
1307  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Underlyings);
1308 
1309  class ONIXS_CMEMDH_LTWT UnderlyingsEntry : public GroupEntry
1310  {
1311  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Underlyings);
1312 
1313  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1314  {
1315  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1316 
1317  static const GroupEntryAccessor& self()
1318  {
1319  static const Accessor self_;
1320  return self_;
1321  }
1322  };
1323 
1324  public:
1325  typedef Binary::UnderlyingsEntry BinaryEntry;
1326 
1327  UnderlyingsEntry(const BinaryEntry& entry)
1328  : GroupEntry(entry, Accessor::self())
1329  {
1330  }
1331  };
1332 
1333  struct ONIXS_CMEMDH_LTWT Underlyings : Group
1334  {
1335  typedef Binary::Underlyings BinaryEntries;
1336 
1337  Underlyings(const BinaryEntries& group)
1338  : Group(group.entries(), UnderlyingsEntry::Accessor::self())
1339  {
1340  }
1341  };
1342 
1343  ONIXS_CMEMDH_LTWT_STRUCT_DECL(RelatedInstruments);
1344 
1345  class ONIXS_CMEMDH_LTWT RelatedInstrumentsEntry : public GroupEntry
1346  {
1347  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(RelatedInstruments);
1348 
1349  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1350  {
1351  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1352 
1353  static const GroupEntryAccessor& self()
1354  {
1355  static const Accessor self_;
1356  return self_;
1357  }
1358  };
1359 
1360  public:
1361  typedef Binary::RelatedInstrumentsEntry BinaryEntry;
1362 
1363  RelatedInstrumentsEntry(const BinaryEntry& entry)
1364  : GroupEntry(entry, Accessor::self())
1365  {
1366  }
1367  };
1368 
1369  struct ONIXS_CMEMDH_LTWT RelatedInstruments : Group
1370  {
1371  typedef Binary::RelatedInstruments BinaryEntries;
1372 
1373  RelatedInstruments(const BinaryEntries& group)
1374  : Group(group.entries(), RelatedInstrumentsEntry::Accessor::self())
1375  {
1376  }
1377  };
1378 
1379  InstrumentDefinitionOption55(const Binary& message)
1380  : Message(message, Accessor::self())
1381  {
1382  }
1383 };
1384 
1385 class ONIXS_CMEMDH_LTWT InstrumentDefinitionSpread56 : public Message
1386 {
1387  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
1388  {
1389  StrRef type() const ONIXS_CMEMDH_OVERRIDE
1390  {
1391  return Binary::fixType();
1392  }
1393 
1394  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1395 
1396  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1397 
1398  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
1399 
1400  static const MessageAccessor& self()
1401  {
1402  static const Accessor self_;
1403  return self_;
1404  }
1405  };
1406 
1407 public:
1408  typedef Base::InstrumentDefinitionSpread56 Binary;
1409 
1410  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
1411 
1412  class ONIXS_CMEMDH_LTWT EventsEntry : public GroupEntry
1413  {
1414  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
1415 
1416  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1417  {
1418  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1419 
1420  static const GroupEntryAccessor& self()
1421  {
1422  static const Accessor self_;
1423  return self_;
1424  }
1425  };
1426 
1427  public:
1428  typedef Binary::EventsEntry BinaryEntry;
1429 
1430  EventsEntry(const BinaryEntry& entry)
1431  : GroupEntry(entry, Accessor::self())
1432  {
1433  }
1434  };
1435 
1436  struct ONIXS_CMEMDH_LTWT Events : Group
1437  {
1438  typedef Binary::Events BinaryEntries;
1439 
1440  Events(const BinaryEntries& group)
1441  : Group(group.entries(), EventsEntry::Accessor::self())
1442  {
1443  }
1444  };
1445 
1446  ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1447 
1448  class ONIXS_CMEMDH_LTWT FeedTypesEntry : public GroupEntry
1449  {
1450  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1451 
1452  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1453  {
1454  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1455 
1456  static const GroupEntryAccessor& self()
1457  {
1458  static const Accessor self_;
1459  return self_;
1460  }
1461  };
1462 
1463  public:
1464  typedef Binary::FeedTypesEntry BinaryEntry;
1465 
1466  FeedTypesEntry(const BinaryEntry& entry)
1467  : GroupEntry(entry, Accessor::self())
1468  {
1469  }
1470  };
1471 
1472  struct ONIXS_CMEMDH_LTWT FeedTypes : Group
1473  {
1474  typedef Binary::FeedTypes BinaryEntries;
1475 
1476  FeedTypes(const BinaryEntries& group)
1477  : Group(group.entries(), FeedTypesEntry::Accessor::self())
1478  {
1479  }
1480  };
1481 
1482  ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1483 
1484  class ONIXS_CMEMDH_LTWT InstAttribEntry : public GroupEntry
1485  {
1486  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1487 
1488  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1489  {
1490  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1491 
1492  static const GroupEntryAccessor& self()
1493  {
1494  static const Accessor self_;
1495  return self_;
1496  }
1497  };
1498 
1499  public:
1500  typedef Binary::InstAttribEntry BinaryEntry;
1501 
1502  InstAttribEntry(const BinaryEntry& entry)
1503  : GroupEntry(entry, Accessor::self())
1504  {
1505  }
1506  };
1507 
1508  struct ONIXS_CMEMDH_LTWT InstAttrib : Group
1509  {
1510  typedef Binary::InstAttrib BinaryEntries;
1511 
1512  InstAttrib(const BinaryEntries& group)
1513  : Group(group.entries(), InstAttribEntry::Accessor::self())
1514  {
1515  }
1516  };
1517 
1518  ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1519 
1520  class ONIXS_CMEMDH_LTWT LotTypeRulesEntry : public GroupEntry
1521  {
1522  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1523 
1524  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1525  {
1526  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1527 
1528  static const GroupEntryAccessor& self()
1529  {
1530  static const Accessor self_;
1531  return self_;
1532  }
1533  };
1534 
1535  public:
1536  typedef Binary::LotTypeRulesEntry BinaryEntry;
1537 
1538  LotTypeRulesEntry(const BinaryEntry& entry)
1539  : GroupEntry(entry, Accessor::self())
1540  {
1541  }
1542  };
1543 
1544  struct ONIXS_CMEMDH_LTWT LotTypeRules : Group
1545  {
1546  typedef Binary::LotTypeRules BinaryEntries;
1547 
1548  LotTypeRules(const BinaryEntries& group)
1549  : Group(group.entries(), LotTypeRulesEntry::Accessor::self())
1550  {
1551  }
1552  };
1553 
1554  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Legs);
1555 
1556  class ONIXS_CMEMDH_LTWT LegsEntry : public GroupEntry
1557  {
1558  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Legs);
1559 
1560  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1561  {
1562  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1563 
1564  static const GroupEntryAccessor& self()
1565  {
1566  static const Accessor self_;
1567  return self_;
1568  }
1569  };
1570 
1571  public:
1572  typedef Binary::LegsEntry BinaryEntry;
1573 
1574  LegsEntry(const BinaryEntry& entry)
1575  : GroupEntry(entry, Accessor::self())
1576  {
1577  }
1578  };
1579 
1580  struct ONIXS_CMEMDH_LTWT Legs : Group
1581  {
1582  typedef Binary::Legs BinaryEntries;
1583 
1584  Legs(const BinaryEntries& group)
1585  : Group(group.entries(), LegsEntry::Accessor::self())
1586  {
1587  }
1588  };
1589 
1590  InstrumentDefinitionSpread56(const Binary& message)
1591  : Message(message, Accessor::self())
1592  {
1593  }
1594 };
1595 
1596 class ONIXS_CMEMDH_LTWT InstrumentDefinitionFixedIncome57 : public Message
1597 {
1598  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
1599  {
1600  StrRef type() const ONIXS_CMEMDH_OVERRIDE
1601  {
1602  return Binary::fixType();
1603  }
1604 
1605  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1606 
1607  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1608 
1609  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
1610 
1611  static const MessageAccessor& self()
1612  {
1613  static const Accessor self_;
1614  return self_;
1615  }
1616  };
1617 
1618 public:
1619  typedef Base::InstrumentDefinitionFixedIncome57 Binary;
1620 
1621  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
1622 
1623  class ONIXS_CMEMDH_LTWT EventsEntry : public GroupEntry
1624  {
1625  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
1626 
1627  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1628  {
1629  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1630 
1631  static const GroupEntryAccessor& self()
1632  {
1633  static const Accessor self_;
1634  return self_;
1635  }
1636  };
1637 
1638  public:
1639  typedef Binary::EventsEntry BinaryEntry;
1640 
1641  EventsEntry(const BinaryEntry& entry)
1642  : GroupEntry(entry, Accessor::self())
1643  {
1644  }
1645  };
1646 
1647  struct ONIXS_CMEMDH_LTWT Events : Group
1648  {
1649  typedef Binary::Events BinaryEntries;
1650 
1651  Events(const BinaryEntries& group)
1652  : Group(group.entries(), EventsEntry::Accessor::self())
1653  {
1654  }
1655  };
1656 
1657  ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1658 
1659  class ONIXS_CMEMDH_LTWT FeedTypesEntry : public GroupEntry
1660  {
1661  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1662 
1663  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1664  {
1665  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1666 
1667  static const GroupEntryAccessor& self()
1668  {
1669  static const Accessor self_;
1670  return self_;
1671  }
1672  };
1673 
1674  public:
1675  typedef Binary::FeedTypesEntry BinaryEntry;
1676 
1677  FeedTypesEntry(const BinaryEntry& entry)
1678  : GroupEntry(entry, Accessor::self())
1679  {
1680  }
1681  };
1682 
1683  struct ONIXS_CMEMDH_LTWT FeedTypes : Group
1684  {
1685  typedef Binary::FeedTypes BinaryEntries;
1686 
1687  FeedTypes(const BinaryEntries& group)
1688  : Group(group.entries(), FeedTypesEntry::Accessor::self())
1689  {
1690  }
1691  };
1692 
1693  ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1694 
1695  class ONIXS_CMEMDH_LTWT InstAttribEntry : public GroupEntry
1696  {
1697  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1698 
1699  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1700  {
1701  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1702 
1703  static const GroupEntryAccessor& self()
1704  {
1705  static const Accessor self_;
1706  return self_;
1707  }
1708  };
1709 
1710  public:
1711  typedef Binary::InstAttribEntry BinaryEntry;
1712 
1713  InstAttribEntry(const BinaryEntry& entry)
1714  : GroupEntry(entry, Accessor::self())
1715  {
1716  }
1717  };
1718 
1719  struct ONIXS_CMEMDH_LTWT InstAttrib : Group
1720  {
1721  typedef Binary::InstAttrib BinaryEntries;
1722 
1723  InstAttrib(const BinaryEntries& group)
1724  : Group(group.entries(), InstAttribEntry::Accessor::self())
1725  {
1726  }
1727  };
1728 
1729  ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1730 
1731  class ONIXS_CMEMDH_LTWT LotTypeRulesEntry : public GroupEntry
1732  {
1733  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1734 
1735  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1736  {
1737  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1738 
1739  static const GroupEntryAccessor& self()
1740  {
1741  static const Accessor self_;
1742  return self_;
1743  }
1744  };
1745 
1746  public:
1747  typedef Binary::LotTypeRulesEntry BinaryEntry;
1748 
1749  LotTypeRulesEntry(const BinaryEntry& entry)
1750  : GroupEntry(entry, Accessor::self())
1751  {
1752  }
1753  };
1754 
1755  struct ONIXS_CMEMDH_LTWT LotTypeRules : Group
1756  {
1757  typedef Binary::LotTypeRules BinaryEntries;
1758 
1759  LotTypeRules(const BinaryEntries& group)
1760  : Group(group.entries(), LotTypeRulesEntry::Accessor::self())
1761  {
1762  }
1763  };
1764 
1765  InstrumentDefinitionFixedIncome57(const Binary& message)
1766  : Message(message, Accessor::self())
1767  {
1768  }
1769 };
1770 
1771 class ONIXS_CMEMDH_LTWT InstrumentDefinitionFX63 : public Message
1772 {
1773  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
1774  {
1775  StrRef type() const ONIXS_CMEMDH_OVERRIDE
1776  {
1777  return Binary::fixType();
1778  }
1779 
1780  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1781 
1782  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1783 
1784  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
1785 
1786  static const MessageAccessor& self()
1787  {
1788  static const Accessor self_;
1789  return self_;
1790  }
1791  };
1792 
1793 public:
1794  typedef Base::InstrumentDefinitionFX63 Binary;
1795 
1796  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Events);
1797 
1798  class ONIXS_CMEMDH_LTWT EventsEntry : public GroupEntry
1799  {
1800  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (Events);
1801 
1802  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1803  {
1804  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1805 
1806  static const GroupEntryAccessor& self()
1807  {
1808  static const Accessor self_;
1809  return self_;
1810  }
1811  };
1812 
1813  public:
1814  typedef Binary::EventsEntry BinaryEntry;
1815 
1816  EventsEntry(const BinaryEntry& entry)
1817  : GroupEntry(entry, Accessor::self())
1818  {
1819  }
1820  };
1821 
1822  struct ONIXS_CMEMDH_LTWT Events : Group
1823  {
1824  typedef Binary::Events BinaryEntries;
1825 
1826  Events( const BinaryEntries& group)
1827  : Group(group.entries(), EventsEntry::Accessor::self())
1828  {
1829  }
1830  };
1831 
1832  ONIXS_CMEMDH_LTWT_STRUCT_DECL(FeedTypes);
1833 
1834  class ONIXS_CMEMDH_LTWT FeedTypesEntry : public GroupEntry
1835  {
1836  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (FeedTypes);
1837 
1838  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1839  {
1840  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1841 
1842  static const GroupEntryAccessor& self()
1843  {
1844  static const Accessor self_;
1845  return self_;
1846  }
1847  };
1848 
1849  public:
1850  typedef Binary::FeedTypesEntry BinaryEntry;
1851 
1852  FeedTypesEntry(const BinaryEntry& entry)
1853  : GroupEntry(entry, Accessor::self())
1854  {
1855  }
1856  };
1857 
1858  struct ONIXS_CMEMDH_LTWT FeedTypes : Group
1859  {
1860  typedef Binary::FeedTypes BinaryEntries;
1861 
1862  FeedTypes( const BinaryEntries& group)
1863  : Group(group.entries(), FeedTypesEntry::Accessor::self())
1864  {
1865  }
1866  };
1867 
1868  ONIXS_CMEMDH_LTWT_STRUCT_DECL(InstAttrib);
1869 
1870  class ONIXS_CMEMDH_LTWT InstAttribEntry : public GroupEntry
1871  {
1872  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (InstAttrib);
1873 
1874  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1875  {
1876  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1877 
1878  static const GroupEntryAccessor& self()
1879  {
1880  static const Accessor self_;
1881  return self_;
1882  }
1883  };
1884 
1885  public:
1886  typedef Binary::InstAttribEntry BinaryEntry;
1887 
1888  InstAttribEntry(const BinaryEntry& entry)
1889  : GroupEntry(entry, Accessor::self())
1890  {
1891  }
1892  };
1893 
1894  struct ONIXS_CMEMDH_LTWT InstAttrib : Group
1895  {
1896  typedef Binary::InstAttrib BinaryEntries;
1897 
1898  InstAttrib( const BinaryEntries& group)
1899  : Group(group.entries(), InstAttribEntry::Accessor::self())
1900  {
1901  }
1902  };
1903 
1904  ONIXS_CMEMDH_LTWT_STRUCT_DECL(LotTypeRules);
1905 
1906  class ONIXS_CMEMDH_LTWT LotTypeRulesEntry : public GroupEntry
1907  {
1908  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (LotTypeRules);
1909 
1910  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1911  {
1912  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1913 
1914  static const GroupEntryAccessor& self()
1915  {
1916  static const Accessor self_;
1917  return self_;
1918  }
1919  };
1920 
1921  public:
1922  typedef Binary::LotTypeRulesEntry BinaryEntry;
1923 
1924  LotTypeRulesEntry(const BinaryEntry& entry)
1925  : GroupEntry(entry, Accessor::self())
1926  {
1927  }
1928  };
1929 
1930  struct ONIXS_CMEMDH_LTWT LotTypeRules : Group
1931  {
1932  typedef Binary::LotTypeRules BinaryEntries;
1933 
1934  LotTypeRules( const BinaryEntries& group)
1935  : Group(group.entries(), LotTypeRulesEntry::Accessor::self())
1936  {
1937  }
1938  };
1939 
1940  ONIXS_CMEMDH_LTWT_STRUCT_DECL(TradingSessions);
1941 
1942  class ONIXS_CMEMDH_LTWT TradingSessionsEntry : public GroupEntry
1943  {
1944  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (TradingSessions);
1945 
1946  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
1947  {
1948  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1949 
1950  static const GroupEntryAccessor& self()
1951  {
1952  static const Accessor self_;
1953  return self_;
1954  }
1955  };
1956 
1957  public:
1958  typedef Binary::TradingSessionsEntry BinaryEntry;
1959 
1960  TradingSessionsEntry(const BinaryEntry& entry)
1961  : GroupEntry(entry, Accessor::self())
1962  {
1963  }
1964  };
1965 
1966  struct ONIXS_CMEMDH_LTWT TradingSessions : Group
1967  {
1968  typedef Binary::TradingSessions BinaryEntries;
1969 
1970  TradingSessions( const BinaryEntries& group)
1971  : Group(group.entries(), TradingSessionsEntry::Accessor::self())
1972  {
1973  }
1974  };
1975 
1976  InstrumentDefinitionFX63(const Binary& message)
1977  : Message(message, Accessor::self())
1978  {
1979  }
1980 };
1981 
1982 class ONIXS_CMEMDH_LTWT IncrementalRefreshBookLongQty64 : public Message
1983 {
1984  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
1985  {
1986  StrRef type() const ONIXS_CMEMDH_OVERRIDE
1987  {
1988  return Binary::fixType();
1989  }
1990 
1991  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1992 
1993  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
1994 
1995  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
1996 
1997  static const MessageAccessor& self()
1998  {
1999  static const Accessor self_;
2000  return self_;
2001  }
2002  };
2003 
2004 public:
2005  typedef Base::IncrementalRefreshBookLongQty64 Binary;
2006 
2007  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
2008 
2009  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
2010  {
2011  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (Entries);
2012 
2013  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
2014  {
2015  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2016 
2017  static const GroupEntryAccessor& self()
2018  {
2019  static const Accessor self_;
2020  return self_;
2021  }
2022  };
2023 
2024  public:
2025  typedef Binary::Entry BinaryEntry;
2026 
2027  Entry(const BinaryEntry& entry)
2028  : GroupEntry(entry, Accessor::self())
2029  {
2030  }
2031  };
2032 
2033  struct ONIXS_CMEMDH_LTWT Entries : Group
2034  {
2035  typedef Binary::Entries BinaryEntries;
2036 
2037  Entries( const BinaryEntries& group)
2038  : Group(group.entries(), Entry::Accessor::self())
2039  {
2040  }
2041  };
2042 
2043  ONIXS_CMEMDH_LTWT_STRUCT_DECL(OrderIDEntries);
2044 
2045  class ONIXS_CMEMDH_LTWT OrderIDEntry : public GroupEntry
2046  {
2047  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (OrderIDEntries);
2048 
2049  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
2050  {
2051  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2052 
2053  static const GroupEntryAccessor& self()
2054  {
2055  static const Accessor self_;
2056  return self_;
2057  }
2058  };
2059 
2060  public:
2061  typedef Binary::OrderIDEntry BinaryEntry;
2062 
2063  OrderIDEntry(const BinaryEntry& entry)
2064  : GroupEntry(entry, Accessor::self())
2065  {
2066  }
2067  };
2068 
2069  struct ONIXS_CMEMDH_LTWT OrderIDEntries : Group
2070  {
2071  typedef Binary::OrderIDEntries BinaryEntries;
2072 
2073  OrderIDEntries( const BinaryEntries& group)
2074  : Group(group.entries(), OrderIDEntry::Accessor::self())
2075  {
2076  }
2077  };
2078 
2079  IncrementalRefreshBookLongQty64(const Binary& message)
2080  : Message(message, Accessor::self())
2081  {
2082  }
2083 };
2084 
2085 class ONIXS_CMEMDH_LTWT IncrementalRefreshTradeSummaryLongQty65 : public Message
2086 {
2087  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
2088  {
2089  StrRef type() const ONIXS_CMEMDH_OVERRIDE
2090  {
2091  return Binary::fixType();
2092  }
2093 
2094  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2095 
2096  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2097 
2098  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
2099 
2100  static const MessageAccessor& self()
2101  {
2102  static const Accessor self_;
2103  return self_;
2104  }
2105  };
2106 
2107 public:
2108  typedef Base::IncrementalRefreshTradeSummaryLongQty65 Binary;
2109 
2110  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
2111 
2112  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
2113  {
2114  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (Entries);
2115 
2116  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
2117  {
2118  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2119 
2120  static const GroupEntryAccessor& self()
2121  {
2122  static const Accessor self_;
2123  return self_;
2124  }
2125  };
2126 
2127  public:
2128  typedef Binary::Entry BinaryEntry;
2129 
2130  Entry(const BinaryEntry& entry)
2131  : GroupEntry(entry, Accessor::self())
2132  {
2133  }
2134  };
2135 
2136  struct ONIXS_CMEMDH_LTWT Entries : Group
2137  {
2138  typedef Binary::Entries BinaryEntries;
2139 
2140  Entries( const BinaryEntries& group)
2141  : Group(group.entries(), Entry::Accessor::self())
2142  {
2143  }
2144  };
2145 
2146  ONIXS_CMEMDH_LTWT_STRUCT_DECL(OrderIDEntries);
2147 
2148  class ONIXS_CMEMDH_LTWT OrderIDEntry : public GroupEntry
2149  {
2150  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (OrderIDEntries);
2151 
2152  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
2153  {
2154  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2155 
2156  static const GroupEntryAccessor& self()
2157  {
2158  static const Accessor self_;
2159  return self_;
2160  }
2161  };
2162 
2163  public:
2164  typedef Binary::OrderIDEntry BinaryEntry;
2165 
2166  OrderIDEntry(const BinaryEntry& entry)
2167  : GroupEntry(entry, Accessor::self())
2168  {
2169  }
2170  };
2171 
2172  struct ONIXS_CMEMDH_LTWT OrderIDEntries : Group
2173  {
2174  typedef Binary::OrderIDEntries BinaryEntries;
2175 
2176  OrderIDEntries( const BinaryEntries& group)
2177  : Group(group.entries(), OrderIDEntry::Accessor::self())
2178  {
2179  }
2180  };
2181 
2182  IncrementalRefreshTradeSummaryLongQty65(const Binary& message)
2183  : Message(message, Accessor::self())
2184  {
2185  }
2186 };
2187 
2188 class ONIXS_CMEMDH_LTWT IncrementalRefreshVolumeLongQty66 : public Message
2189 {
2190  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
2191  {
2192  StrRef type() const ONIXS_CMEMDH_OVERRIDE
2193  {
2194  return Binary::fixType();
2195  }
2196 
2197  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2198 
2199  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2200 
2201  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
2202 
2203  static const MessageAccessor& self()
2204  {
2205  static const Accessor self_;
2206  return self_;
2207  }
2208  };
2209 
2210 public:
2211  typedef Base::IncrementalRefreshVolumeLongQty66 Binary;
2212 
2213  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
2214 
2215  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
2216  {
2217  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (Entries);
2218 
2219  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
2220  {
2221  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2222 
2223  static const GroupEntryAccessor& self()
2224  {
2225  static const Accessor self_;
2226  return self_;
2227  }
2228  };
2229 
2230  public:
2231  typedef Binary::Entry BinaryEntry;
2232 
2233  Entry(const BinaryEntry& entry)
2234  : GroupEntry(entry, Accessor::self())
2235  {
2236  }
2237  };
2238 
2239  struct ONIXS_CMEMDH_LTWT Entries : Group
2240  {
2241  typedef Binary::Entries BinaryEntries;
2242 
2243  Entries( const BinaryEntries& group)
2244  : Group(group.entries(), Entry::Accessor::self())
2245  {
2246  }
2247  };
2248 
2249  IncrementalRefreshVolumeLongQty66(const Binary& message)
2250  : Message(message, Accessor::self())
2251  {
2252  }
2253 };
2254 
2255 class ONIXS_CMEMDH_LTWT IncrementalRefreshSessionStatisticsLongQty67 : public Message
2256 {
2257  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
2258  {
2259  StrRef type() const ONIXS_CMEMDH_OVERRIDE
2260  {
2261  return Binary::fixType();
2262  }
2263 
2264  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2265 
2266  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2267 
2268  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
2269 
2270  static const MessageAccessor& self()
2271  {
2272  static const Accessor self_;
2273  return self_;
2274  }
2275  };
2276 
2277 public:
2278  typedef Base::IncrementalRefreshSessionStatisticsLongQty67 Binary;
2279 
2280  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
2281 
2282  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
2283  {
2284  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (Entries);
2285 
2286  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
2287  {
2288  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2289 
2290  static const GroupEntryAccessor& self()
2291  {
2292  static const Accessor self_;
2293  return self_;
2294  }
2295  };
2296 
2297  public:
2298  typedef Binary::Entry BinaryEntry;
2299 
2300  Entry(const BinaryEntry& entry)
2301  : GroupEntry(entry, Accessor::self())
2302  {
2303  }
2304  };
2305 
2306  struct ONIXS_CMEMDH_LTWT Entries : Group
2307  {
2308  typedef Binary::Entries BinaryEntries;
2309 
2310  Entries( const BinaryEntries& group)
2311  : Group(group.entries(), Entry::Accessor::self())
2312  {
2313  }
2314  };
2315 
2316  IncrementalRefreshSessionStatisticsLongQty67(const Binary& message)
2317  : Message(message, Accessor::self())
2318  {
2319  }
2320 };
2321 
2322 class ONIXS_CMEMDH_LTWT SnapshotFullRefreshLongQty69 : public Message
2323 {
2324  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
2325  {
2326  StrRef type() const ONIXS_CMEMDH_OVERRIDE
2327  {
2328  return Binary::fixType();
2329  }
2330 
2331  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2332 
2333  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2334 
2335  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
2336 
2337  static const MessageAccessor& self()
2338  {
2339  static const Accessor self_;
2340  return self_;
2341  }
2342  };
2343 
2344 public:
2345  typedef Base::SnapshotFullRefreshLongQty69 Binary;
2346 
2347  ONIXS_CMEMDH_LTWT_STRUCT_DECL(Entries);
2348 
2349  class ONIXS_CMEMDH_LTWT Entry : public GroupEntry
2350  {
2351  friend ONIXS_CMEMDH_LTWT_STRUCT_DECL (Entries);
2352 
2353  struct ONIXS_CMEMDH_EXPORTED Accessor : GroupEntryAccessor
2354  {
2355  Field field(const GroupEntrySource&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2356 
2357  static const GroupEntryAccessor& self()
2358  {
2359  static const Accessor self_;
2360  return self_;
2361  }
2362  };
2363 
2364  public:
2365  typedef Binary::Entry BinaryEntry;
2366 
2367  Entry(const BinaryEntry& entry)
2368  : GroupEntry(entry, Accessor::self())
2369  {
2370  }
2371  };
2372 
2373  struct ONIXS_CMEMDH_LTWT Entries : Group
2374  {
2375  typedef Binary::Entries BinaryEntries;
2376 
2377  Entries( const BinaryEntries& group)
2378  : Group(group.entries(), Entry::Accessor::self())
2379  {
2380  }
2381  };
2382 
2383  SnapshotFullRefreshLongQty69(const Binary& message)
2384  : Message(message, Accessor::self())
2385  {
2386  }
2387 };
2388 
2389 class ONIXS_CMEMDH_LTWT AdminLogin408 : public Message
2390 {
2391  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
2392  {
2393  StrRef type() const ONIXS_CMEMDH_OVERRIDE
2394  {
2395  return Binary::fixType();
2396  }
2397 
2398  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2399 
2400  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2401 
2402  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
2403 
2404  static const MessageAccessor& self()
2405  {
2406  static const Accessor self_;
2407  return self_;
2408  }
2409  };
2410 
2411 public:
2412  typedef Base::AdminLogin408 Binary;
2413 
2414  AdminLogin408(const Binary& message)
2415  : Message(message, Accessor::self())
2416  {
2417  }
2418 };
2419 
2420 class ONIXS_CMEMDH_LTWT AdminLogout409 : public Message
2421 {
2422  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
2423  {
2424  StrRef type() const ONIXS_CMEMDH_OVERRIDE
2425  {
2426  return Binary::fixType();
2427  }
2428 
2429  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2430 
2431  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2432 
2433  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
2434 
2435  static const MessageAccessor& self()
2436  {
2437  static const Accessor self_;
2438  return self_;
2439  }
2440  };
2441 
2442 public:
2443  typedef Base::AdminLogout409 Binary;
2444 
2445  AdminLogout409(const Binary& message)
2446  : Message(message, Accessor::self())
2447  {
2448  }
2449 };
2450 
2451 class ONIXS_CMEMDH_LTWT AdminHeartbeat410 : public Message
2452 {
2453  struct ONIXS_CMEMDH_EXPORTED Accessor : MessageAccessor
2454  {
2455  StrRef type() const ONIXS_CMEMDH_OVERRIDE
2456  {
2457  return Binary::fixType();
2458  }
2459 
2460  Field field(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2461 
2462  Group group(const BinaryMessage&, Tag) const ONIXS_CMEMDH_OVERRIDE;
2463 
2464  void toFix(std::string&, const BinaryMessage&) const ONIXS_CMEMDH_OVERRIDE;
2465 
2466  static const MessageAccessor& self()
2467  {
2468  static const Accessor self_;
2469  return self_;
2470  }
2471  };
2472 
2473 public:
2474  typedef Base::AdminHeartbeat410 Binary;
2475 
2476  AdminHeartbeat410(const Binary& message)
2477  : Message(message, Accessor::self())
2478  {
2479  }
2480 };
2481 
2482 
2483 
2484 ONIXS_CMEMDHFIX_NAMESPACE_END
OnixS::CME::MDH::FIX::ChannelReset4::Entry::Entry
Entry(const BinaryEntry &entry)
Definition: Messages.h:75
OnixS::CME::MDH::IncrementalRefreshSessionStatistics51
MDIncrementalRefreshSessionStatistics.
Definition: Messages.h:3650
OnixS::CME::MDH::FIX::InstrumentDefinitionSpread56::Binary
Base::InstrumentDefinitionSpread56 Binary
Definition: Messages.h:1408
OnixS::CME::MDH::FIX::IncrementalRefreshTradeSummary48::Binary
Base::IncrementalRefreshTradeSummary48 Binary
Definition: Messages.h:548
OnixS::CME::MDH::IncrementalRefreshBookLongQty64
MDIncrementalRefreshBookLongQty.
Definition: Messages.h:6740
OnixS::CME::MDH::IncrementalRefreshBookLongQty64::Entry
Number of entries in Market Data message.
Definition: Messages.h:6750
OnixS::CME::MDH::SnapshotFullRefreshLongQty69
SnapshotFullRefreshLongQty.
Definition: Messages.h:7562
OnixS::CME::MDH::FIX::InstrumentDefinitionOption55::Binary
Base::InstrumentDefinitionOption55 Binary
Definition: Messages.h:1161
ONIXS_CMEMDH_OVERRIDE
#define ONIXS_CMEMDH_OVERRIDE
Definition: Compiler.h:176
OnixS::CME::MDH::SnapshotFullRefreshOrderBook53
SnapshotFullRefreshOrderBook.
Definition: Messages.h:5676
OnixS::CME::MDH::IncrementalRefreshBook46
MDIncrementalRefreshBook.
Definition: Messages.h:3015
OnixS::CME::MDH::IncrementalRefreshVolume37::Entry
Number of entries in Market Data message.
Definition: Messages.h:3826
OnixS::CME::MDH::FIX::IncrementalRefreshBookLongQty64::Binary
Base::IncrementalRefreshBookLongQty64 Binary
Definition: Messages.h:2005
OnixS::CME::MDH::FIX::IncrementalRefreshDailyStatistics49::Binary
Base::IncrementalRefreshDailyStatistics49 Binary
Definition: Messages.h:651
OnixS::CME::MDH::FIX::SnapshotFullRefresh52::Binary
Base::SnapshotFullRefresh52 Binary
Definition: Messages.h:852
OnixS::CME::MDH::InstrumentDefinitionFX63
MDInstrumentDefinitionFX.
Definition: Messages.h:5858
OnixS::CME::MDH::IncrementalRefreshBook46::Entry
Number of entries in Market Data message.
Definition: Messages.h:3025
OnixS::CME::MDH::FIX::AdminLogout16::Binary
Base::AdminLogout16 Binary
Definition: Messages.h:182
OnixS::CME::MDH::FIX::IncrementalRefreshOrderBook47::IncrementalRefreshOrderBook47
IncrementalRefreshOrderBook47(const Binary &message)
Definition: Messages.h:519
OnixS::CME::MDH::FIX::InstrumentDefinitionFuture54::Binary
Base::InstrumentDefinitionFuture54 Binary
Definition: Messages.h:986
OnixS::CME::MDH::InstrumentDefinitionFixedIncome57::InstAttribEntry
Number of repeating InstrAttribType entries.
Definition: Messages.h:153
ONIXS_CMEMDHFIX_NAMESPACE_BEGIN
#define ONIXS_CMEMDHFIX_NAMESPACE_BEGIN
Definition: Bootstrap.h:70
OnixS::CME::MDH::FIX::SecurityStatus30::Binary
Base::SecurityStatus30 Binary
Definition: Messages.h:213
OnixS::CME::MDH::FIX::MessageAccessor
Implements FIX-like services for the SBE-encoded message.
Definition: Message.h:197
OnixS::CME::MDH::IncrementalRefreshVolumeLongQty66
MDIncrementalRefreshVolumeLongQty.
Definition: Messages.h:7251
OnixS::CME::MDH::IncrementalRefreshTradeSummaryLongQty65::OrderIDEntry
Number of OrderID and LastQty entries in Trade Summary message.
Definition: Messages.h:7133
OnixS::CME::MDH::SnapshotFullRefreshLongQty69::Entry
Number of entries in Market Data message.
Definition: Messages.h:7572
OnixS::CME::MDH::FIX::SnapshotFullRefreshOrderBook53::Binary
Base::SnapshotFullRefreshOrderBook53 Binary
Definition: Messages.h:919
OnixS::CME::MDH::FIX::InstrumentDefinitionFX63::Binary
Base::InstrumentDefinitionFX63 Binary
Definition: Messages.h:1794
OnixS::CME::MDH::FIX::AdminLogin15::AdminLogin15
AdminLogin15(const Binary &message)
Definition: Messages.h:153
OnixS::CME::MDH::toFix
void toFix(std::string &str, AggressorFlag::Enum value)
Serializes object into FIX presentation.
Definition: Serialization.h:46
OnixS::CME::MDH::IncrementalRefreshDailyStatistics49
MDIncrementalRefreshDailyStatistics.
Definition: Messages.h:3298
OnixS::CME::MDH::QuoteRequest39::RelatedSymEntry
Indicates the number of repeating symbols specified.
Definition: Messages.h:4256
OnixS::CME::MDH::FIX::ChannelReset4::Entries::Entries
Entries(const BinaryEntries &group)
Definition: Messages.h:85
ONIXS_CMEMDH_LTWT
#define ONIXS_CMEMDH_LTWT
Definition: Bootstrap.h:46
OnixS::CME::MDH::FIX::SecurityStatus30::SecurityStatus30
SecurityStatus30(const Binary &message)
Definition: Messages.h:215
OnixS::CME::MDH::FIX::InstrumentDefinitionFX63::InstrumentDefinitionFX63
InstrumentDefinitionFX63(const Binary &message)
Definition: Messages.h:1976
OnixS::CME::MDH::FIX::IncrementalRefreshBook46::IncrementalRefreshBook46
IncrementalRefreshBook46(const Binary &message)
Definition: Messages.h:452
OnixS::CME::MDH::FIX::IncrementalRefreshTradeSummaryLongQty65::Binary
Base::IncrementalRefreshTradeSummaryLongQty65 Binary
Definition: Messages.h:2108
OnixS::CME::MDH::FIX::AdminLogout409::AdminLogout409
AdminLogout409(const Binary &message)
Definition: Messages.h:2445
OnixS::CME::MDH::SnapshotFullRefreshOrderBook53::Entry
Number of entries in Market Data message.
Definition: Messages.h:5686
OnixS::CME::MDH::ChannelReset4::Entry
Number of entries in Market Data message.
Definition: Messages.h:877
OnixS::CME::MDH::IncrementalRefreshOrderBook47
MDIncrementalRefreshOrderBook.
Definition: Messages.h:5505
OnixS::CME::MDH::FIX::ChannelReset4::ChannelReset4
ChannelReset4(const Binary &message)
Definition: Messages.h:91
OnixS::CME::MDH::FIX::IncrementalRefreshSessionStatisticsLongQty67::Binary
Base::IncrementalRefreshSessionStatisticsLongQty67 Binary
Definition: Messages.h:2278
ONIXS_CMEMDHFIX_NAMESPACE_END
#define ONIXS_CMEMDHFIX_NAMESPACE_END
Definition: Bootstrap.h:71
OnixS::CME::MDH::FIX::AdminHeartbeat410::AdminHeartbeat410
AdminHeartbeat410(const Binary &message)
Definition: Messages.h:2476
OnixS::CME::MDH::FIX::AdminLogin408::AdminLogin408
AdminLogin408(const Binary &message)
Definition: Messages.h:2414
OnixS::CME::MDH::IncrementalRefreshLimitsBanding50::Entry
Number of entries in Market Data message.
Definition: Messages.h:3494
OnixS::CME::MDH::FIX::QuoteRequest39::RelatedSym::RelatedSym
RelatedSym(const BinaryEntries &group)
Definition: Messages.h:343
OnixS::CME::MDH::StrRef
Provides efficient way of accessing text-based values without copying content of the text being refer...
Definition: String.h:41
OnixS::CME::MDH::InstrumentDefinitionSpread56
MDInstrumentDefinitionSpread.
Definition: Messages.h:2056
OnixS::CME::MDH::IncrementalRefreshDailyStatistics49::Entry
Number of entries in Market Data message.
Definition: Messages.h:3308
OnixS::CME::MDH::InstrumentDefinitionFixedIncome57::EventsEntry
Number of repeating EventType entries.
Definition: Messages.h:42
OnixS::CME::MDH::FIX::SnapshotFullRefresh52::SnapshotFullRefresh52
SnapshotFullRefresh52(const Binary &message)
Definition: Messages.h:890
OnixS::CME::MDH::FIX::IncrementalRefreshVolume37::IncrementalRefreshVolume37
IncrementalRefreshVolume37(const Binary &message)
Definition: Messages.h:282
OnixS::CME::MDH::InstrumentDefinitionFuture54::InstAttribEntry
Number of repeating InstrAttribType entries.
Definition: Messages.h:1415
OnixS::CME::MDH::FIX::QuoteRequest39::Binary
Base::QuoteRequest39 Binary
Definition: Messages.h:311
OnixS::CME::MDH::FIX::IncrementalRefreshOrderBook47::Binary
Base::IncrementalRefreshOrderBook47 Binary
Definition: Messages.h:481
OnixS::CME::MDH::FIX::IncrementalRefreshLimitsBanding50::Binary
Base::IncrementalRefreshLimitsBanding50 Binary
Definition: Messages.h:718
OnixS::CME::MDH::FIX::AdminHeartbeat12::Binary
Base::AdminHeartbeat12 Binary
Definition: Messages.h:120
OnixS::CME::MDH::IncrementalRefreshTradeSummary48
MDIncrementalRefreshTradeSummary.
Definition: Messages.h:5263
OnixS::CME::MDH::FIX::InstrumentDefinitionFixedIncome57::Binary
Base::InstrumentDefinitionFixedIncome57 Binary
Definition: Messages.h:1619
OnixS::CME::MDH::FIX::Group
Implements a FIX repeating group over the SBE-encoded binary data.
Definition: Message.h:131
OnixS::CME::MDH::BinaryMessage
Encapsulates services for manipulating SBE-encoded messages.
Definition: BinaryMessage.h:883
OnixS::CME::MDH::FIX::ChannelReset4::Binary
Base::ChannelReset4 Binary
Definition: Messages.h:53
OnixS::CME::MDH::FIX::GroupEntry
Provides FIX-like access to the fields stored in a SBE-encoded repeating group.
Definition: Message.h:58
ONIXS_CMEMDH_EXPORTED
#define ONIXS_CMEMDH_EXPORTED
Definition: Compiler.h:171
OnixS::CME::MDH::FIX::IncrementalRefreshVolume37::Binary
Base::IncrementalRefreshVolume37 Binary
Definition: Messages.h:244
OnixS::CME::MDH::FIX::SnapshotFullRefreshLongQty69::Binary
Base::SnapshotFullRefreshLongQty69 Binary
Definition: Messages.h:2345
OnixS::CME::MDH::FIX::Message
Implements FIX-like interface over the SBE-encoded message.
Definition: Message.h:215
OnixS::CME::MDH::IncrementalRefreshTradeSummaryLongQty65
MDIncrementalRefreshTradeSummaryLongQty.
Definition: Messages.h:7009
OnixS::CME::MDH::FIX::IncrementalRefreshBook46::Binary
Base::IncrementalRefreshBook46 Binary
Definition: Messages.h:378
OnixS::CME::MDH::IncrementalRefreshVolumeLongQty66::Entry
Number of entries in Market Data message.
Definition: Messages.h:7261
OnixS::CME::MDH::FIX::Tag
UInt32 Tag
The type whose values are used to locate fields in the FIX-like messages.
Definition: Tag.h:29
OnixS::CME::MDH::FIX::GroupEntryAccessor
Provides FIX-like access to the fields stored in a SBE-encoded repeating group.
Definition: Message.h:49
OnixS::CME::MDH::BinaryGroup
Encapsulates operations over SBE-encoded repeating group.
Definition: BinaryMessage.h:637
OnixS::CME::MDH::IncrementalRefreshSessionStatistics51::Entry
Number of entries in Market Data message.
Definition: Messages.h:3660
OnixS::CME::MDH::IncrementalRefreshVolume37
MDIncrementalRefreshVolume.
Definition: Messages.h:3816
OnixS::CME::MDH::InstrumentDefinitionFixedIncome57::FeedTypesEntry
Number of repeating FeedType repeating group entries.
Definition: Messages.h:97
OnixS::CME::MDH::InstrumentDefinitionFuture54::EventsEntry
Number of repeating EventType entries.
Definition: Messages.h:1304
OnixS::CME::MDH::SnapshotFullRefresh52::Entry
Number of entries in Market Data message.
Definition: Messages.h:3971
ONIXS_CMEMDH_LTWT_STRUCT_DECL
#define ONIXS_CMEMDH_LTWT_STRUCT_DECL(name)
Definition: Bootstrap.h:49
OnixS::CME::MDH::FIX::AdminLogout16::AdminLogout16
AdminLogout16(const Binary &message)
Definition: Messages.h:184
OnixS::CME::MDH::InstrumentDefinitionFuture54
MDInstrumentDefinitionFuture.
Definition: Messages.h:1294
OnixS::CME::MDH::InstrumentDefinitionOption55
MDInstrumentDefinitionOption.
Definition: Messages.h:4406
OnixS::CME::MDH::IncrementalRefreshSessionStatisticsLongQty67
MDIncrementalRefreshSessionStatisticsLongQty.
Definition: Messages.h:7396
OnixS::CME::MDH::InstrumentDefinitionSpread56::EventsEntry
Number of repeating EventType entries.
Definition: Messages.h:2066
OnixS::CME::MDH::FIX::AdminHeartbeat12::AdminHeartbeat12
AdminHeartbeat12(const Binary &message)
Definition: Messages.h:122
OnixS::CME::MDH::FIX::QuoteRequest39::QuoteRequest39
QuoteRequest39(const Binary &message)
Definition: Messages.h:349
OnixS::CME::MDH::FIX::IncrementalRefreshVolumeLongQty66::Binary
Base::IncrementalRefreshVolumeLongQty66 Binary
Definition: Messages.h:2211
OnixS::CME::MDH::FIX::IncrementalRefreshSessionStatistics51::Binary
Base::IncrementalRefreshSessionStatistics51 Binary
Definition: Messages.h:785
OnixS::CME::MDH::InstrumentDefinitionFixedIncome57
MDInstrumentDefinitionFixedIncome.
Definition: Messages.h:32
OnixS::CME::MDH::FIX::AdminHeartbeat410::Binary
Base::AdminHeartbeat410 Binary
Definition: Messages.h:2474
OnixS::CME::MDH::FIX::Field
Represents the field in the FIX message.
Definition: Field.h:32
OnixS::CME::MDH::IncrementalRefreshLimitsBanding50
MDIncrementalRefreshLimitsBanding.
Definition: Messages.h:3484
OnixS::CME::MDH::IncrementalRefreshOrderBook47::Entry
Number of entries in Market Data message.
Definition: Messages.h:5515