OnixS C++ CME MDP Conflated TCP Handler  1.3.1
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 <cassert>
24 #include <stdexcept>
25 
26 #include <OnixS/CME/ConflatedTCP/ABI.h>
27 #include <OnixS/CME/ConflatedTCP/messaging/Composites.h>
28 #include <OnixS/CME/ConflatedTCP/messaging/SbeMessage.h>
29 
30 ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_BEGIN
31 
32 /// Negotiate.
33 ONIXS_CONFLATEDTCP_LTWT_STRUCT
34 Negotiate200
35 : SbeMessage
36 {
37  /// Used template schema.
38  typedef SchemaTraits Schema;
39 
40  /// This type alias.
41  typedef Negotiate200 ThisType;
42 
43  /// Message template ID from SBE schema.
44  enum { TemplateId = 200 };
45 
46  /// Initializes a blank instance.
47  Negotiate200() ONIXS_CONFLATEDTCP_DEFAULT;
48 
49  /// Initializes an instance over the given memory block.
50  Negotiate200(
51  void* data,
52  EncodedLength length,
53  SchemaVersion version = Schema::Version)
54  : SbeMessage(data, length, version)
55  {
56  checkVersion<Schema>(version);
57  checkLength(length, version);
58  initHeader(TemplateId, blockLength(version), Schema::Id);
59  reset();
60  }
61 
62  /// Initializes an instance over the given memory block
63  /// With no variable-length fields initialization
64  /// It is assumed that the user does such an initialization manually.
65  Negotiate200(
66  void* data,
67  EncodedLength length,
68  NoFieldsInit,
69  SchemaVersion version = Schema::Version)
70  : SbeMessage(data, length, version)
71  {
72  checkVersion<Schema>(version);
73  checkLength(length, version);
74  initHeader(TemplateId, blockLength(version), Schema::Id);
75  resetVariableFields();
76  }
77 
78  /// Initializes an instance over the given memory block.
79  Negotiate200(
80  void* data,
81  EncodedLength length,
82  NoInit)
83  : SbeMessage(data, length)
84  {
85  checkCompatibility();
86  }
87 
88  /// Initializes an instance over the given SBE message.
89  explicit
90  Negotiate200(
91  const SbeMessage& message)
92  : SbeMessage(message)
93  {
94  assert(message.valid());
95 
96  checkCompatibility();
97  }
98 
99  /// Initializes an instance over the given memory block.
100  /// Performs no checks.
101  Negotiate200(
102  void* data,
103  EncodedLength length,
104  NoInit,
105  NoCheck)
106  ONIXS_CONFLATEDTCP_NOTHROW
107  : SbeMessage(data, length, NoCheck())
108  {
109  assert(schemaId() == Schema::Id);
110  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
111  assert(TemplateId == templateId());
112  }
113 
114  /// Constant value representing CME HMAC version.
115  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
116  ONIXS_CONFLATEDTCP_NODISCARD
117  ONIXS_CONFLATEDTCP_CONSTEXPR
118  static StrRef hmacVersion()
119  ONIXS_CONFLATEDTCP_NOTHROW
120  {
121  return constructStrRef("CME-1-SHA-256");
122  }
123 
124  /// Contains the HMAC signature.
125  ONIXS_CONFLATEDTCP_NODISCARD
126  StrRef hmacSignature() const
127  ONIXS_CONFLATEDTCP_NOTHROW
128  {
129  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
130  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 32;
131 
132  return fixedStr<length>(offset);
133  }
134 
135  /// Contains the HMAC signature.
136  ThisType& setHmacSignature(StrRef value)
137  ONIXS_CONFLATEDTCP_NOTHROW
138  {
139  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
140  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 32;
141 
142  setFixedStr<length>(offset, value);
143  return *this;
144  }
145 
146  /// Contains the AccessKeyID assigned to this session on this
147  /// port.
148  ONIXS_CONFLATEDTCP_NODISCARD
149  StrRef accessKeyId() const
150  ONIXS_CONFLATEDTCP_NOTHROW
151  {
152  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 32;
153  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 20;
154 
155  return fixedStr<length>(offset);
156  }
157 
158  /// Contains the AccessKeyID assigned to this session on this
159  /// port.
160  ThisType& setAccessKeyId(StrRef value)
161  ONIXS_CONFLATEDTCP_NOTHROW
162  {
163  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 32;
164  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 20;
165 
166  setFixedStr<length>(offset, value);
167  return *this;
168  }
169 
170  /// Session Identifier defined as type long uInt64,
171  /// recommended to use timestamp as number of microseconds
172  /// since Unix epoch.
173  ONIXS_CONFLATEDTCP_NODISCARD
174  UInt64 uuId() const
175  ONIXS_CONFLATEDTCP_NOTHROW
176  {
177  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 52;
178 
179  return ordinary<UInt64>(offset);
180  }
181 
182  /// Session Identifier defined as type long uInt64,
183  /// recommended to use timestamp as number of microseconds
184  /// since Unix epoch.
185  ThisType& setUuId(UInt64 value)
186  ONIXS_CONFLATEDTCP_NOTHROW
187  {
188  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 52;
189 
190  setOrdinary(offset, value);
191  return *this;
192  }
193 
194  /// Time of request, recommended to use timestamp as number of
195  /// nanoseconds since Unix epoch.
196  ONIXS_CONFLATEDTCP_NODISCARD
197  Timestamp requestTimestamp() const
198  ONIXS_CONFLATEDTCP_NOTHROW
199  {
200  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 60;
201 
202  return ordinary<Timestamp>(offset);
203  }
204 
205  /// Time of request, recommended to use timestamp as number of
206  /// nanoseconds since Unix epoch.
207  ThisType& setRequestTimestamp(Timestamp value)
208  ONIXS_CONFLATEDTCP_NOTHROW
209  {
210  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 60;
211 
212  setOrdinary(offset, value.sinceEpoch());
213  return *this;
214  }
215 
216  /// Session ID.
217  ONIXS_CONFLATEDTCP_NODISCARD
218  StrRef session() const
219  ONIXS_CONFLATEDTCP_NOTHROW
220  {
221  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 68;
222  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 5;
223 
224  return fixedStr<length>(offset);
225  }
226 
227  /// Session ID.
228  ThisType& setSession(StrRef value)
229  ONIXS_CONFLATEDTCP_NOTHROW
230  {
231  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 68;
232  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 5;
233 
234  setFixedStr<length>(offset, value);
235  return *this;
236  }
237 
238  /// Firm ID.
239  ONIXS_CONFLATEDTCP_NODISCARD
240  StrRef firm() const
241  ONIXS_CONFLATEDTCP_NOTHROW
242  {
243  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 73;
244  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 5;
245 
246  return fixedStr<length>(offset);
247  }
248 
249  /// Firm ID.
250  ThisType& setFirm(StrRef value)
251  ONIXS_CONFLATEDTCP_NOTHROW
252  {
253  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 73;
254  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 5;
255 
256  setFixedStr<length>(offset, value);
257  return *this;
258  }
259 
260  /// Size of message body in bytes.
261  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
262  ONIXS_CONFLATEDTCP_CONSTEXPR
263  static
264  BlockLength
265  blockLength(
266  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
267  ONIXS_CONFLATEDTCP_NOTHROW
268  {
269  return
270  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
271  78;
272  }
273 
274  /// Minimal variable fields size (when variable-length fields are empty).
275  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
276  ONIXS_CONFLATEDTCP_NODISCARD
277  ONIXS_CONFLATEDTCP_CONSTEXPR
278  static
279  MessageSize
280  getMinimalVariableFieldsSize(
281  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
282  {
283  return
284  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
285  0;
286  }
287 
288  /// Maximal message size.
289  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
290  ONIXS_CONFLATEDTCP_NODISCARD
291  ONIXS_CONFLATEDTCP_CONSTEXPR
292  static UInt64 getMaxMessageSize(UInt8)
293  ONIXS_CONFLATEDTCP_NOTHROW
294  {
295  return
296  static_cast<UInt64>(MessageHeaderBuilder::Size) +
297  blockLength(Schema::Version);
298  }
299 
300  /// Reset all variable-length fields if any.
301  ThisType& resetVariableFields()
302  ONIXS_CONFLATEDTCP_NOTHROW
303  {
304  return *this;
305  }
306 
307  /// Reset all variable-length and optional fields if any.
308  ThisType& reset()
309  ONIXS_CONFLATEDTCP_NOTHROW
310  {
311  resetVariableFields();
312  return *this;
313  }
314 
315  /// \return class name.
316  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
317  ONIXS_CONFLATEDTCP_NODISCARD
318  ONIXS_CONFLATEDTCP_CONSTEXPR
319  static const Char* className()
320  {
321  return "Negotiate200";
322  }
323 
324  /// FIX message type.
325  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
326  ONIXS_CONFLATEDTCP_NODISCARD
327  ONIXS_CONFLATEDTCP_CONSTEXPR
328  static StrRef fixType()
329  ONIXS_CONFLATEDTCP_NOTHROW
330  {
331  return constructStrRef("MsgTypeNeg");
332  }
333 
334  /// \return a human-readable presentation.
335  ONIXS_CONFLATEDTCP_NODISCARD
336  std::string toString() const;
337 
338  /// \return the end of the message.
339  ONIXS_CONFLATEDTCP_NODISCARD
340  const void* tail() const
341  ONIXS_CONFLATEDTCP_NOTHROW
342  {
343  return
344  toOpaquePtr(
345  advanceByBytes(
346  binary(),
347  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
348  MessageHeader::Size));
349  }
350 
351  /// \return the size occupied by the message.
352  ONIXS_CONFLATEDTCP_NODISCARD
353  EncodedLength calculateBinarySize() const
354  ONIXS_CONFLATEDTCP_NOTHROW
355  {
356  return
357  SbeMessage::calculateBinarySize(tail());
358  }
359 
360 private:
361  void checkLength(
362  EncodedLength length, SchemaVersion version) const
363  {
364  const EncodedLength minimalRequiredLength =
365  blockLength(version) +
366  MessageHeader::Size +
367  getMinimalVariableFieldsSize(version);
368 
369  checkBinaryLength(
370  *this, length, minimalRequiredLength);
371  }
372 
373  void checkCompatibility() const
374  {
375  assert(TemplateId == templateId());
376 
377  checkSchema<Schema>(schemaId(), version());
378  checkLength(bufferSize(), version());
379  }
380 };
381 
382 /// NegotiationReject.
383 ONIXS_CONFLATEDTCP_LTWT_STRUCT
384 NegotiationReject201
385 : SbeMessage
386 {
387  /// Used template schema.
388  typedef SchemaTraits Schema;
389 
390  /// This type alias.
391  typedef NegotiationReject201 ThisType;
392 
393  /// Message template ID from SBE schema.
394  enum { TemplateId = 201 };
395 
396  /// Initializes a blank instance.
397  NegotiationReject201() ONIXS_CONFLATEDTCP_DEFAULT;
398 
399  /// Initializes an instance over the given memory block.
400  NegotiationReject201(
401  void* data,
402  EncodedLength length,
403  SchemaVersion version = Schema::Version)
404  : SbeMessage(data, length, version)
405  {
406  checkVersion<Schema>(version);
407  checkLength(length, version);
408  initHeader(TemplateId, blockLength(version), Schema::Id);
409  reset();
410  }
411 
412  /// Initializes an instance over the given memory block
413  /// With no variable-length fields initialization
414  /// It is assumed that the user does such an initialization manually.
415  NegotiationReject201(
416  void* data,
417  EncodedLength length,
418  NoFieldsInit,
419  SchemaVersion version = Schema::Version)
420  : SbeMessage(data, length, version)
421  {
422  checkVersion<Schema>(version);
423  checkLength(length, version);
424  initHeader(TemplateId, blockLength(version), Schema::Id);
425  resetVariableFields();
426  }
427 
428  /// Initializes an instance over the given memory block.
429  NegotiationReject201(
430  void* data,
431  EncodedLength length,
432  NoInit)
433  : SbeMessage(data, length)
434  {
435  checkCompatibility();
436  }
437 
438  /// Initializes an instance over the given SBE message.
439  explicit
440  NegotiationReject201(
441  const SbeMessage& message)
442  : SbeMessage(message)
443  {
444  assert(message.valid());
445 
446  checkCompatibility();
447  }
448 
449  /// Initializes an instance over the given memory block.
450  /// Performs no checks.
451  NegotiationReject201(
452  void* data,
453  EncodedLength length,
454  NoInit,
455  NoCheck)
456  ONIXS_CONFLATEDTCP_NOTHROW
457  : SbeMessage(data, length, NoCheck())
458  {
459  assert(schemaId() == Schema::Id);
460  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
461  assert(TemplateId == templateId());
462  }
463 
464  /// Reject reason details.
465  ONIXS_CONFLATEDTCP_NODISCARD
466  StrRef reason() const
467  ONIXS_CONFLATEDTCP_NOTHROW
468  {
469  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
470  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 48;
471 
472  return fixedStr<length>(offset);
473  }
474 
475  /// Reject reason details.
476  ThisType& setReason(StrRef value)
477  ONIXS_CONFLATEDTCP_NOTHROW
478  {
479  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
480  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 48;
481 
482  setFixedStr<length>(offset, value);
483  return *this;
484  }
485 
486  /// Matches Negotiate.UUID.
487  ONIXS_CONFLATEDTCP_NODISCARD
488  UInt64 uuId() const
489  ONIXS_CONFLATEDTCP_NOTHROW
490  {
491  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 48;
492 
493  return ordinary<UInt64>(offset);
494  }
495 
496  /// Matches Negotiate.UUID.
497  ThisType& setUuId(UInt64 value)
498  ONIXS_CONFLATEDTCP_NOTHROW
499  {
500  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 48;
501 
502  setOrdinary(offset, value);
503  return *this;
504  }
505 
506  /// Matches Negotiate.RequestTimestamp.
507  ONIXS_CONFLATEDTCP_NODISCARD
508  Timestamp requestTimestamp() const
509  ONIXS_CONFLATEDTCP_NOTHROW
510  {
511  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 56;
512 
513  return ordinary<Timestamp>(offset);
514  }
515 
516  /// Matches Negotiate.RequestTimestamp.
517  ThisType& setRequestTimestamp(Timestamp value)
518  ONIXS_CONFLATEDTCP_NOTHROW
519  {
520  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 56;
521 
522  setOrdinary(offset, value.sinceEpoch());
523  return *this;
524  }
525 
526  /// Error code for reject reason.
527  ONIXS_CONFLATEDTCP_NODISCARD
528  ErrorCodes::Enum errorCodes() const
529  ONIXS_CONFLATEDTCP_NOTHROW
530  {
531  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 64;
532 
533  return enumeration<ErrorCodes>(offset);
534  }
535 
536  /// Error code for reject reason.
537  ThisType& setErrorCodes(ErrorCodes::Enum value)
538  ONIXS_CONFLATEDTCP_NOTHROW
539  {
540  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 64;
541 
542  setEnumeration<ErrorCodes>(offset, value);
543  return *this;
544  }
545 
546  /// Size of message body in bytes.
547  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
548  ONIXS_CONFLATEDTCP_CONSTEXPR
549  static
550  BlockLength
551  blockLength(
552  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
553  ONIXS_CONFLATEDTCP_NOTHROW
554  {
555  return
556  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
557  65;
558  }
559 
560  /// Minimal variable fields size (when variable-length fields are empty).
561  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
562  ONIXS_CONFLATEDTCP_NODISCARD
563  ONIXS_CONFLATEDTCP_CONSTEXPR
564  static
565  MessageSize
566  getMinimalVariableFieldsSize(
567  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
568  {
569  return
570  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
571  0;
572  }
573 
574  /// Maximal message size.
575  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
576  ONIXS_CONFLATEDTCP_NODISCARD
577  ONIXS_CONFLATEDTCP_CONSTEXPR
578  static UInt64 getMaxMessageSize(UInt8)
579  ONIXS_CONFLATEDTCP_NOTHROW
580  {
581  return
582  static_cast<UInt64>(MessageHeaderBuilder::Size) +
583  blockLength(Schema::Version);
584  }
585 
586  /// Reset all variable-length fields if any.
587  ThisType& resetVariableFields()
588  ONIXS_CONFLATEDTCP_NOTHROW
589  {
590  return *this;
591  }
592 
593  /// Reset all variable-length and optional fields if any.
594  ThisType& reset()
595  ONIXS_CONFLATEDTCP_NOTHROW
596  {
597  resetVariableFields();
598  return *this;
599  }
600 
601  /// \return class name.
602  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
603  ONIXS_CONFLATEDTCP_NODISCARD
604  ONIXS_CONFLATEDTCP_CONSTEXPR
605  static const Char* className()
606  {
607  return "NegotiationReject201";
608  }
609 
610  /// FIX message type.
611  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
612  ONIXS_CONFLATEDTCP_NODISCARD
613  ONIXS_CONFLATEDTCP_CONSTEXPR
614  static StrRef fixType()
615  ONIXS_CONFLATEDTCP_NOTHROW
616  {
617  return constructStrRef("NegotiationReject");
618  }
619 
620  /// \return a human-readable presentation.
621  ONIXS_CONFLATEDTCP_NODISCARD
622  std::string toString() const;
623 
624  /// \return the end of the message.
625  ONIXS_CONFLATEDTCP_NODISCARD
626  const void* tail() const
627  ONIXS_CONFLATEDTCP_NOTHROW
628  {
629  return
630  toOpaquePtr(
631  advanceByBytes(
632  binary(),
633  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
634  MessageHeader::Size));
635  }
636 
637  /// \return the size occupied by the message.
638  ONIXS_CONFLATEDTCP_NODISCARD
639  EncodedLength calculateBinarySize() const
640  ONIXS_CONFLATEDTCP_NOTHROW
641  {
642  return
643  SbeMessage::calculateBinarySize(tail());
644  }
645 
646 private:
647  void checkLength(
648  EncodedLength length, SchemaVersion version) const
649  {
650  const EncodedLength minimalRequiredLength =
651  blockLength(version) +
652  MessageHeader::Size +
653  getMinimalVariableFieldsSize(version);
654 
655  checkBinaryLength(
656  *this, length, minimalRequiredLength);
657  }
658 
659  void checkCompatibility() const
660  {
661  assert(TemplateId == templateId());
662 
663  checkSchema<Schema>(schemaId(), version());
664  checkLength(bufferSize(), version());
665  }
666 };
667 
668 /// NegotiationResponse.
669 ONIXS_CONFLATEDTCP_LTWT_STRUCT
670 NegotiationResponse202
671 : SbeMessage
672 {
673  /// Used template schema.
674  typedef SchemaTraits Schema;
675 
676  /// This type alias.
677  typedef NegotiationResponse202 ThisType;
678 
679  /// Message template ID from SBE schema.
680  enum { TemplateId = 202 };
681 
682  /// Initializes a blank instance.
683  NegotiationResponse202() ONIXS_CONFLATEDTCP_DEFAULT;
684 
685  /// Initializes an instance over the given memory block.
686  NegotiationResponse202(
687  void* data,
688  EncodedLength length,
689  SchemaVersion version = Schema::Version)
690  : SbeMessage(data, length, version)
691  {
692  checkVersion<Schema>(version);
693  checkLength(length, version);
694  initHeader(TemplateId, blockLength(version), Schema::Id);
695  reset();
696  }
697 
698  /// Initializes an instance over the given memory block
699  /// With no variable-length fields initialization
700  /// It is assumed that the user does such an initialization manually.
701  NegotiationResponse202(
702  void* data,
703  EncodedLength length,
704  NoFieldsInit,
705  SchemaVersion version = Schema::Version)
706  : SbeMessage(data, length, version)
707  {
708  checkVersion<Schema>(version);
709  checkLength(length, version);
710  initHeader(TemplateId, blockLength(version), Schema::Id);
711  resetVariableFields();
712  }
713 
714  /// Initializes an instance over the given memory block.
715  NegotiationResponse202(
716  void* data,
717  EncodedLength length,
718  NoInit)
719  : SbeMessage(data, length)
720  {
721  checkCompatibility();
722  }
723 
724  /// Initializes an instance over the given SBE message.
725  explicit
726  NegotiationResponse202(
727  const SbeMessage& message)
728  : SbeMessage(message)
729  {
730  assert(message.valid());
731 
732  checkCompatibility();
733  }
734 
735  /// Initializes an instance over the given memory block.
736  /// Performs no checks.
737  NegotiationResponse202(
738  void* data,
739  EncodedLength length,
740  NoInit,
741  NoCheck)
742  ONIXS_CONFLATEDTCP_NOTHROW
743  : SbeMessage(data, length, NoCheck())
744  {
745  assert(schemaId() == Schema::Id);
746  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
747  assert(TemplateId == templateId());
748  }
749 
750  /// Matches Negotiate.UUID.
751  ONIXS_CONFLATEDTCP_NODISCARD
752  UInt64 uuId() const
753  ONIXS_CONFLATEDTCP_NOTHROW
754  {
755  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
756 
757  return ordinary<UInt64>(offset);
758  }
759 
760  /// Matches Negotiate.UUID.
761  ThisType& setUuId(UInt64 value)
762  ONIXS_CONFLATEDTCP_NOTHROW
763  {
764  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
765 
766  setOrdinary(offset, value);
767  return *this;
768  }
769 
770  /// Matches Negotiate.RequestTimestamp.
771  ONIXS_CONFLATEDTCP_NODISCARD
772  Timestamp requestTimestamp() const
773  ONIXS_CONFLATEDTCP_NOTHROW
774  {
775  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 8;
776 
777  return ordinary<Timestamp>(offset);
778  }
779 
780  /// Matches Negotiate.RequestTimestamp.
781  ThisType& setRequestTimestamp(Timestamp value)
782  ONIXS_CONFLATEDTCP_NOTHROW
783  {
784  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 8;
785 
786  setOrdinary(offset, value.sinceEpoch());
787  return *this;
788  }
789 
790  /// This indicates in how many days the HMAC secret key will
791  /// expire.
792  ONIXS_CONFLATEDTCP_NODISCARD
793  bool secretKeySecureIdExpiration(UInt16NULL& value) const
794  ONIXS_CONFLATEDTCP_NOTHROW
795  {
796  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 16;
797 
798  return ordinary(value, offset, NullUInt16NULL());
799  }
800 
801  /// This indicates in how many days the HMAC secret key will
802  /// expire.
803  ThisType& setSecretKeySecureIdExpiration(UInt16NULL value)
804  ONIXS_CONFLATEDTCP_NOTHROW
805  {
806  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 16;
807 
808  setOrdinary(offset, value);
809  return *this;
810  }
811 
812  ThisType& setSecretKeySecureIdExpirationToNull()
813  ONIXS_CONFLATEDTCP_NOTHROW
814  {
815  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 16;
816 
817  setOrdinary(offset, NullUInt16NULL());
818  return *this;
819  }
820 
821  /// Size of message body in bytes.
822  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
823  ONIXS_CONFLATEDTCP_CONSTEXPR
824  static
825  BlockLength
826  blockLength(
827  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
828  ONIXS_CONFLATEDTCP_NOTHROW
829  {
830  return
831  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
832  18;
833  }
834 
835  /// Minimal variable fields size (when variable-length fields are empty).
836  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
837  ONIXS_CONFLATEDTCP_NODISCARD
838  ONIXS_CONFLATEDTCP_CONSTEXPR
839  static
840  MessageSize
841  getMinimalVariableFieldsSize(
842  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
843  {
844  return
845  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
846  0;
847  }
848 
849  /// Maximal message size.
850  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
851  ONIXS_CONFLATEDTCP_NODISCARD
852  ONIXS_CONFLATEDTCP_CONSTEXPR
853  static UInt64 getMaxMessageSize(UInt8)
854  ONIXS_CONFLATEDTCP_NOTHROW
855  {
856  return
857  static_cast<UInt64>(MessageHeaderBuilder::Size) +
858  blockLength(Schema::Version);
859  }
860 
861  /// Reset all variable-length fields if any.
862  ThisType& resetVariableFields()
863  ONIXS_CONFLATEDTCP_NOTHROW
864  {
865  return *this;
866  }
867 
868  /// Reset all variable-length and optional fields if any.
869  ThisType& reset()
870  ONIXS_CONFLATEDTCP_NOTHROW
871  {
872  setSecretKeySecureIdExpirationToNull();
873 
874  resetVariableFields();
875  return *this;
876  }
877 
878  /// \return class name.
879  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
880  ONIXS_CONFLATEDTCP_NODISCARD
881  ONIXS_CONFLATEDTCP_CONSTEXPR
882  static const Char* className()
883  {
884  return "NegotiationResponse202";
885  }
886 
887  /// FIX message type.
888  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
889  ONIXS_CONFLATEDTCP_NODISCARD
890  ONIXS_CONFLATEDTCP_CONSTEXPR
891  static StrRef fixType()
892  ONIXS_CONFLATEDTCP_NOTHROW
893  {
894  return constructStrRef("NegotiationResponse");
895  }
896 
897  /// \return a human-readable presentation.
898  ONIXS_CONFLATEDTCP_NODISCARD
899  std::string toString() const;
900 
901  /// \return the end of the message.
902  ONIXS_CONFLATEDTCP_NODISCARD
903  const void* tail() const
904  ONIXS_CONFLATEDTCP_NOTHROW
905  {
906  return
907  toOpaquePtr(
908  advanceByBytes(
909  binary(),
910  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
911  MessageHeader::Size));
912  }
913 
914  /// \return the size occupied by the message.
915  ONIXS_CONFLATEDTCP_NODISCARD
916  EncodedLength calculateBinarySize() const
917  ONIXS_CONFLATEDTCP_NOTHROW
918  {
919  return
920  SbeMessage::calculateBinarySize(tail());
921  }
922 
923 private:
924  void checkLength(
925  EncodedLength length, SchemaVersion version) const
926  {
927  const EncodedLength minimalRequiredLength =
928  blockLength(version) +
929  MessageHeader::Size +
930  getMinimalVariableFieldsSize(version);
931 
932  checkBinaryLength(
933  *this, length, minimalRequiredLength);
934  }
935 
936  void checkCompatibility() const
937  {
938  assert(TemplateId == templateId());
939 
940  checkSchema<Schema>(schemaId(), version());
941  checkLength(bufferSize(), version());
942  }
943 };
944 
945 /// Terminate.
946 ONIXS_CONFLATEDTCP_LTWT_STRUCT
947 Terminate203
948 : SbeMessage
949 {
950  /// Used template schema.
951  typedef SchemaTraits Schema;
952 
953  /// This type alias.
954  typedef Terminate203 ThisType;
955 
956  /// Message template ID from SBE schema.
957  enum { TemplateId = 203 };
958 
959  /// Initializes a blank instance.
960  Terminate203() ONIXS_CONFLATEDTCP_DEFAULT;
961 
962  /// Initializes an instance over the given memory block.
963  Terminate203(
964  void* data,
965  EncodedLength length,
966  SchemaVersion version = Schema::Version)
967  : SbeMessage(data, length, version)
968  {
969  checkVersion<Schema>(version);
970  checkLength(length, version);
971  initHeader(TemplateId, blockLength(version), Schema::Id);
972  reset();
973  }
974 
975  /// Initializes an instance over the given memory block
976  /// With no variable-length fields initialization
977  /// It is assumed that the user does such an initialization manually.
978  Terminate203(
979  void* data,
980  EncodedLength length,
981  NoFieldsInit,
982  SchemaVersion version = Schema::Version)
983  : SbeMessage(data, length, version)
984  {
985  checkVersion<Schema>(version);
986  checkLength(length, version);
987  initHeader(TemplateId, blockLength(version), Schema::Id);
988  resetVariableFields();
989  }
990 
991  /// Initializes an instance over the given memory block.
992  Terminate203(
993  void* data,
994  EncodedLength length,
995  NoInit)
996  : SbeMessage(data, length)
997  {
998  checkCompatibility();
999  }
1000 
1001  /// Initializes an instance over the given SBE message.
1002  explicit
1003  Terminate203(
1004  const SbeMessage& message)
1005  : SbeMessage(message)
1006  {
1007  assert(message.valid());
1008 
1009  checkCompatibility();
1010  }
1011 
1012  /// Initializes an instance over the given memory block.
1013  /// Performs no checks.
1014  Terminate203(
1015  void* data,
1016  EncodedLength length,
1017  NoInit,
1018  NoCheck)
1019  ONIXS_CONFLATEDTCP_NOTHROW
1020  : SbeMessage(data, length, NoCheck())
1021  {
1022  assert(schemaId() == Schema::Id);
1023  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
1024  assert(TemplateId == templateId());
1025  }
1026 
1027  /// Reject reason details.
1028  ONIXS_CONFLATEDTCP_NODISCARD
1029  StrRef reason() const
1030  ONIXS_CONFLATEDTCP_NOTHROW
1031  {
1032  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1033  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 48;
1034 
1035  return fixedStr<length>(offset);
1036  }
1037 
1038  /// Reject reason details.
1039  ThisType& setReason(StrRef value)
1040  ONIXS_CONFLATEDTCP_NOTHROW
1041  {
1042  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1043  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 48;
1044 
1045  setFixedStr<length>(offset, value);
1046  return *this;
1047  }
1048 
1049  /// Matches Negotiate.UUID.
1050  ONIXS_CONFLATEDTCP_NODISCARD
1051  UInt64 uuId() const
1052  ONIXS_CONFLATEDTCP_NOTHROW
1053  {
1054  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 48;
1055 
1056  return ordinary<UInt64>(offset);
1057  }
1058 
1059  /// Matches Negotiate.UUID.
1060  ThisType& setUuId(UInt64 value)
1061  ONIXS_CONFLATEDTCP_NOTHROW
1062  {
1063  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 48;
1064 
1065  setOrdinary(offset, value);
1066  return *this;
1067  }
1068 
1069  /// Matches last received Negotiate.RequestTimestamp.
1070  ONIXS_CONFLATEDTCP_NODISCARD
1071  Timestamp requestTimestamp() const
1072  ONIXS_CONFLATEDTCP_NOTHROW
1073  {
1074  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 56;
1075 
1076  return ordinary<Timestamp>(offset);
1077  }
1078 
1079  /// Matches last received Negotiate.RequestTimestamp.
1080  ThisType& setRequestTimestamp(Timestamp value)
1081  ONIXS_CONFLATEDTCP_NOTHROW
1082  {
1083  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 56;
1084 
1085  setOrdinary(offset, value.sinceEpoch());
1086  return *this;
1087  }
1088 
1089  /// Error code for reject reason.
1090  ONIXS_CONFLATEDTCP_NODISCARD
1091  ErrorCodes::Enum errorCodes() const
1092  ONIXS_CONFLATEDTCP_NOTHROW
1093  {
1094  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 64;
1095 
1096  return enumeration<ErrorCodes>(offset);
1097  }
1098 
1099  /// Error code for reject reason.
1100  ThisType& setErrorCodes(ErrorCodes::Enum value)
1101  ONIXS_CONFLATEDTCP_NOTHROW
1102  {
1103  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 64;
1104 
1105  setEnumeration<ErrorCodes>(offset, value);
1106  return *this;
1107  }
1108 
1109  /// Size of message body in bytes.
1110  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1111  ONIXS_CONFLATEDTCP_CONSTEXPR
1112  static
1113  BlockLength
1114  blockLength(
1115  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
1116  ONIXS_CONFLATEDTCP_NOTHROW
1117  {
1118  return
1119  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
1120  70;
1121  }
1122 
1123  /// Minimal variable fields size (when variable-length fields are empty).
1124  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1125  ONIXS_CONFLATEDTCP_NODISCARD
1126  ONIXS_CONFLATEDTCP_CONSTEXPR
1127  static
1128  MessageSize
1129  getMinimalVariableFieldsSize(
1130  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
1131  {
1132  return
1133  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
1134  0;
1135  }
1136 
1137  /// Maximal message size.
1138  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1139  ONIXS_CONFLATEDTCP_NODISCARD
1140  ONIXS_CONFLATEDTCP_CONSTEXPR
1141  static UInt64 getMaxMessageSize(UInt8)
1142  ONIXS_CONFLATEDTCP_NOTHROW
1143  {
1144  return
1145  static_cast<UInt64>(MessageHeaderBuilder::Size) +
1146  blockLength(Schema::Version);
1147  }
1148 
1149  /// Reset all variable-length fields if any.
1150  ThisType& resetVariableFields()
1151  ONIXS_CONFLATEDTCP_NOTHROW
1152  {
1153  return *this;
1154  }
1155 
1156  /// Reset all variable-length and optional fields if any.
1157  ThisType& reset()
1158  ONIXS_CONFLATEDTCP_NOTHROW
1159  {
1160  resetVariableFields();
1161  return *this;
1162  }
1163 
1164  /// \return class name.
1165  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1166  ONIXS_CONFLATEDTCP_NODISCARD
1167  ONIXS_CONFLATEDTCP_CONSTEXPR
1168  static const Char* className()
1169  {
1170  return "Terminate203";
1171  }
1172 
1173  /// FIX message type.
1174  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1175  ONIXS_CONFLATEDTCP_NODISCARD
1176  ONIXS_CONFLATEDTCP_CONSTEXPR
1177  static StrRef fixType()
1178  ONIXS_CONFLATEDTCP_NOTHROW
1179  {
1180  return constructStrRef("Terminate");
1181  }
1182 
1183  /// \return a human-readable presentation.
1184  ONIXS_CONFLATEDTCP_NODISCARD
1185  std::string toString() const;
1186 
1187  /// \return the end of the message.
1188  ONIXS_CONFLATEDTCP_NODISCARD
1189  const void* tail() const
1190  ONIXS_CONFLATEDTCP_NOTHROW
1191  {
1192  return
1193  toOpaquePtr(
1194  advanceByBytes(
1195  binary(),
1196  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
1197  MessageHeader::Size));
1198  }
1199 
1200  /// \return the size occupied by the message.
1201  ONIXS_CONFLATEDTCP_NODISCARD
1202  EncodedLength calculateBinarySize() const
1203  ONIXS_CONFLATEDTCP_NOTHROW
1204  {
1205  return
1206  SbeMessage::calculateBinarySize(tail());
1207  }
1208 
1209 private:
1210  void checkLength(
1211  EncodedLength length, SchemaVersion version) const
1212  {
1213  const EncodedLength minimalRequiredLength =
1214  blockLength(version) +
1215  MessageHeader::Size +
1216  getMinimalVariableFieldsSize(version);
1217 
1218  checkBinaryLength(
1219  *this, length, minimalRequiredLength);
1220  }
1221 
1222  void checkCompatibility() const
1223  {
1224  assert(TemplateId == templateId());
1225 
1226  checkSchema<Schema>(schemaId(), version());
1227  checkLength(bufferSize(), version());
1228  }
1229 };
1230 
1231 /// MarketDataRequest.
1232 ONIXS_CONFLATEDTCP_LTWT_STRUCT
1233 MarketDataRequest205
1234 : SbeMessage
1235 {
1236  /// Used template schema.
1237  typedef SchemaTraits Schema;
1238 
1239  /// This type alias.
1240  typedef MarketDataRequest205 ThisType;
1241 
1242  /// Message template ID from SBE schema.
1243  enum { TemplateId = 205 };
1244 
1245  /// Number of SecurityGroups specified in subscription
1246  /// request. Should be equal 0, when subscription is requested
1247  /// for all groups on the segment or individual Security IDs
1248  /// are listed in the criteria for subscription.
1249  /// Entry of SecurityGroupsEntry repeating group.
1250  ONIXS_CONFLATEDTCP_LTWT_STRUCT
1251  SecurityGroupsEntry : SbeGroupEntry
1252  <
1253  GroupSize::BlockLength
1254  >
1255  {
1256  /// Base class type.
1257  typedef
1258  SbeGroupEntry
1259  <
1260  GroupSize::BlockLength
1261  >
1262  Base;
1263 
1264  /// This type alias.
1265  typedef SecurityGroupsEntry ThisType;
1266 
1267  /// Initializes instance of given
1268  /// version over given memory block.
1269  SecurityGroupsEntry(
1270  void* data,
1271  EncodedLength length,
1272  SchemaVersion version)
1273  : Base(data, length, version)
1274  {
1275  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
1276  assert(length >= blockLength(version));
1277  }
1278 
1279  /// Reset all variable-length fields if any.
1280  ThisType& resetVariableFields()
1281  ONIXS_CONFLATEDTCP_NOTHROW
1282  {
1283  return *this;
1284  }
1285 
1286  /// Reset all variable-length and optional fields if any.
1287  ThisType& reset()
1288  ONIXS_CONFLATEDTCP_NOTHROW
1289  {
1290  resetVariableFields();
1291  return *this;
1292  }
1293 
1294  /// Security Group.
1295  ONIXS_CONFLATEDTCP_NODISCARD
1296  StrRef securityGroup() const
1297  ONIXS_CONFLATEDTCP_NOTHROW
1298  {
1299  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1300  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
1301 
1302  return fixedStr<length>(offset);
1303  }
1304 
1305  /// Security Group.
1306  ThisType& setSecurityGroup(StrRef value)
1307  ONIXS_CONFLATEDTCP_NOTHROW
1308  {
1309  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1310  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
1311 
1312  setFixedStr<length>(offset, value);
1313  return *this;
1314  }
1315 
1316  /// \return size of entry body in bytes
1317  /// for given version of message template.
1318  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1319  ONIXS_CONFLATEDTCP_CONSTEXPR
1320  static
1321  BlockLength
1322  blockLength(
1323  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
1324  ONIXS_CONFLATEDTCP_NOTHROW
1325  {
1326  return
1327  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
1328  6;
1329  }
1330 
1331  /// Entity class name.
1332  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1333  ONIXS_CONFLATEDTCP_NODISCARD
1334  ONIXS_CONFLATEDTCP_CONSTEXPR
1335  static const Char* className()
1336  {
1337  return "MarketDataRequest205.SecurityGroupsEntry";
1338  }
1339  };
1340 
1341  /// Repeating group containing SecurityGroupsEntry entries.
1342  typedef
1343  SbeGroup<SecurityGroupsEntry, GroupSize, MessageSize>
1344  SecurityGroups;
1345 
1346  /// Number of instruments requested. When NoSecurityGroups > 0
1347  /// specified in the request, the NoRelatedSym should be
1348  /// equal 0.
1349  /// Entry of RelatedSymEntry repeating group.
1350  ONIXS_CONFLATEDTCP_LTWT_STRUCT
1351  RelatedSymEntry : SbeGroupEntry
1352  <
1353  GroupSize::BlockLength
1354  >
1355  {
1356  /// Base class type.
1357  typedef
1358  SbeGroupEntry
1359  <
1360  GroupSize::BlockLength
1361  >
1362  Base;
1363 
1364  /// This type alias.
1365  typedef RelatedSymEntry ThisType;
1366 
1367  /// Initializes instance of given
1368  /// version over given memory block.
1369  RelatedSymEntry(
1370  void* data,
1371  EncodedLength length,
1372  SchemaVersion version)
1373  : Base(data, length, version)
1374  {
1375  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
1376  assert(length >= blockLength(version));
1377  }
1378 
1379  /// Reset all variable-length fields if any.
1380  ThisType& resetVariableFields()
1381  ONIXS_CONFLATEDTCP_NOTHROW
1382  {
1383  return *this;
1384  }
1385 
1386  /// Reset all variable-length and optional fields if any.
1387  ThisType& reset()
1388  ONIXS_CONFLATEDTCP_NOTHROW
1389  {
1390  resetVariableFields();
1391  return *this;
1392  }
1393 
1394  /// Security ID.
1395  ONIXS_CONFLATEDTCP_NODISCARD
1396  Int32 securityId() const
1397  ONIXS_CONFLATEDTCP_NOTHROW
1398  {
1399  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1400 
1401  return ordinary<Int32>(offset);
1402  }
1403 
1404  /// Security ID.
1405  ThisType& setSecurityId(Int32 value)
1406  ONIXS_CONFLATEDTCP_NOTHROW
1407  {
1408  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1409 
1410  setOrdinary(offset, value);
1411  return *this;
1412  }
1413 
1414  /// \return size of entry body in bytes
1415  /// for given version of message template.
1416  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1417  ONIXS_CONFLATEDTCP_CONSTEXPR
1418  static
1419  BlockLength
1420  blockLength(
1421  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
1422  ONIXS_CONFLATEDTCP_NOTHROW
1423  {
1424  return
1425  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
1426  4;
1427  }
1428 
1429  /// Entity class name.
1430  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1431  ONIXS_CONFLATEDTCP_NODISCARD
1432  ONIXS_CONFLATEDTCP_CONSTEXPR
1433  static const Char* className()
1434  {
1435  return "MarketDataRequest205.RelatedSymEntry";
1436  }
1437  };
1438 
1439  /// Repeating group containing RelatedSymEntry entries.
1440  typedef
1441  SbeGroup<RelatedSymEntry, GroupSize, MessageSize>
1442  RelatedSym;
1443 
1444  /// Initializes a blank instance.
1445  MarketDataRequest205() ONIXS_CONFLATEDTCP_DEFAULT;
1446 
1447  /// Initializes an instance over the given memory block.
1448  MarketDataRequest205(
1449  void* data,
1450  EncodedLength length,
1451  SchemaVersion version = Schema::Version)
1452  : SbeMessage(data, length, version)
1453  {
1454  checkVersion<Schema>(version);
1455  checkLength(length, version);
1456  initHeader(TemplateId, blockLength(version), Schema::Id);
1457  reset();
1458  }
1459 
1460  /// Initializes an instance over the given memory block
1461  /// With no variable-length fields initialization
1462  /// It is assumed that the user does such an initialization manually.
1463  MarketDataRequest205(
1464  void* data,
1465  EncodedLength length,
1466  NoFieldsInit,
1467  SchemaVersion version = Schema::Version)
1468  : SbeMessage(data, length, version)
1469  {
1470  checkVersion<Schema>(version);
1471  checkLength(length, version);
1472  initHeader(TemplateId, blockLength(version), Schema::Id);
1473  resetVariableFields();
1474  }
1475 
1476  /// Initializes an instance over the given memory block.
1477  MarketDataRequest205(
1478  void* data,
1479  EncodedLength length,
1480  NoInit)
1481  : SbeMessage(data, length)
1482  {
1483  checkCompatibility();
1484  }
1485 
1486  /// Initializes an instance over the given SBE message.
1487  explicit
1488  MarketDataRequest205(
1489  const SbeMessage& message)
1490  : SbeMessage(message)
1491  {
1492  assert(message.valid());
1493 
1494  checkCompatibility();
1495  }
1496 
1497  /// Initializes an instance over the given memory block.
1498  /// Performs no checks.
1499  MarketDataRequest205(
1500  void* data,
1501  EncodedLength length,
1502  NoInit,
1503  NoCheck)
1504  ONIXS_CONFLATEDTCP_NOTHROW
1505  : SbeMessage(data, length, NoCheck())
1506  {
1507  assert(schemaId() == Schema::Id);
1508  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
1509  assert(TemplateId == templateId());
1510  }
1511 
1512  /// Unique identifier for Market Data Request. Must be unique
1513  /// per session so it can be referenced in Request Ack or
1514  /// Request Reject responses from the exchange.
1515  ONIXS_CONFLATEDTCP_NODISCARD
1516  UInt32 reqId() const
1517  ONIXS_CONFLATEDTCP_NOTHROW
1518  {
1519  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1520 
1521  return ordinary<UInt32>(offset);
1522  }
1523 
1524  /// Unique identifier for Market Data Request. Must be unique
1525  /// per session so it can be referenced in Request Ack or
1526  /// Request Reject responses from the exchange.
1527  ThisType& setReqId(UInt32 value)
1528  ONIXS_CONFLATEDTCP_NOTHROW
1529  {
1530  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1531 
1532  setOrdinary(offset, value);
1533  return *this;
1534  }
1535 
1536  /// Subscription Request Type indicates to the type of
1537  /// response expected.
1538  ONIXS_CONFLATEDTCP_NODISCARD
1539  SubscriptionReqType::Enum
1540  subscriptionReqType() const
1541  ONIXS_CONFLATEDTCP_NOTHROW
1542  {
1543  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
1544 
1545  return enumeration<SubscriptionReqType>(offset);
1546  }
1547 
1548  /// Subscription Request Type indicates to the type of
1549  /// response expected.
1550  ThisType&
1551  setSubscriptionReqType(
1552  SubscriptionReqType::Enum value)
1553  ONIXS_CONFLATEDTCP_NOTHROW
1554  {
1555  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
1556 
1557  setEnumeration<SubscriptionReqType>(offset, value);
1558  return *this;
1559  }
1560 
1561  /// \return instance of SecurityGroups repeating group.
1562  ONIXS_CONFLATEDTCP_NODISCARD
1563  SecurityGroups securityGroups() const
1564  ONIXS_CONFLATEDTCP_NOTHROW
1565  {
1566  return getGroup<SecurityGroups>(
1567  SecurityGroupsAccess(),
1568  *this);
1569  }
1570 
1571  /// \return instance of SecurityGroups repeating group.
1572  ONIXS_CONFLATEDTCP_NODISCARD
1573  SecurityGroups securityGroups()
1574  ONIXS_CONFLATEDTCP_NOTHROW
1575  {
1576  return getGroup<SecurityGroups>(
1577  SecurityGroupsAccess(),
1578  *this);
1579  }
1580 
1581  /// Setup repeating group with the given number of entries.
1582  /// Sets all optional fields of the group entries to null.
1583  /// \return NoSecurityGroups(37022) repeating group.
1584  SecurityGroups
1585  securityGroups(
1586  SecurityGroups::Size length)
1587  {
1588  return constructGroup<SecurityGroups>(
1589  SecurityGroupsAccess(),
1590  length,
1591  *this);
1592  }
1593 
1594  /// Setup repeating group with the given number of entries.
1595  /// \return NoSecurityGroups(37022) repeating group.
1596  SecurityGroups
1597  securityGroups(
1598  SecurityGroups::Size length,
1599  NoFieldsInit)
1600  {
1601  return setupGroup<SecurityGroups>(
1602  SecurityGroupsAccess(),
1603  length,
1604  *this);
1605  }
1606 
1607  /// \return instance of RelatedSym repeating group.
1608  ONIXS_CONFLATEDTCP_NODISCARD
1609  RelatedSym relatedSym() const
1610  ONIXS_CONFLATEDTCP_NOTHROW
1611  {
1612  return getGroup<RelatedSym>(
1613  RelatedSymAccess(),
1614  *this);
1615  }
1616 
1617  /// \return instance of RelatedSym repeating group.
1618  ONIXS_CONFLATEDTCP_NODISCARD
1619  RelatedSym relatedSym()
1620  ONIXS_CONFLATEDTCP_NOTHROW
1621  {
1622  return getGroup<RelatedSym>(
1623  RelatedSymAccess(),
1624  *this);
1625  }
1626 
1627  /// Setup repeating group with the given number of entries.
1628  /// Sets all optional fields of the group entries to null.
1629  /// \return NoRelatedSym(146) repeating group.
1630  RelatedSym relatedSym(RelatedSym::Size length)
1631  {
1632  return constructGroup<RelatedSym>(
1633  RelatedSymAccess(),
1634  length,
1635  *this);
1636  }
1637 
1638  /// Setup repeating group with the given number of entries.
1639  /// \return NoRelatedSym(146) repeating group.
1640  RelatedSym
1641  relatedSym(
1642  RelatedSym::Size length,
1643  NoFieldsInit)
1644  {
1645  return setupGroup<RelatedSym>(
1646  RelatedSymAccess(),
1647  length,
1648  *this);
1649  }
1650 
1651  /// Size of message body in bytes.
1652  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1653  ONIXS_CONFLATEDTCP_CONSTEXPR
1654  static
1655  BlockLength
1656  blockLength(
1657  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
1658  ONIXS_CONFLATEDTCP_NOTHROW
1659  {
1660  return
1661  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
1662  5;
1663  }
1664 
1665  /// Minimal variable fields size (when variable-length fields are empty).
1666  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1667  ONIXS_CONFLATEDTCP_NODISCARD
1668  ONIXS_CONFLATEDTCP_CONSTEXPR
1669  static
1670  MessageSize
1671  getMinimalVariableFieldsSize(
1672  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
1673  {
1674  return
1675  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
1676  SecurityGroups::EmptySize + RelatedSym::EmptySize;
1677  }
1678 
1679  /// Maximal message size.
1680  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1681  ONIXS_CONFLATEDTCP_NODISCARD
1682  ONIXS_CONFLATEDTCP_CONSTEXPR
1683  static
1684  UInt64
1685  getMaxMessageSize(
1686  UInt8 maxGroupItems = 255)
1687  ONIXS_CONFLATEDTCP_NOTHROW
1688  {
1689  return
1690  static_cast<UInt64>(MessageHeaderBuilder::Size) +
1691  blockLength(Schema::Version) +
1692  (GroupSize::Size + SecurityGroupsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems)) +
1693  (GroupSize::Size + RelatedSymEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
1694  }
1695 
1696  /// Reset all variable-length fields if any.
1697  ThisType& resetVariableFields()
1698  ONIXS_CONFLATEDTCP_NOTHROW
1699  {
1700  setSecurityGroupsToNull();
1701  setRelatedSymToNull();
1702  return *this;
1703  }
1704 
1705  /// Reset all variable-length and optional fields if any.
1706  ThisType& reset()
1707  ONIXS_CONFLATEDTCP_NOTHROW
1708  {
1709  resetVariableFields();
1710  return *this;
1711  }
1712 
1713  /// \return class name.
1714  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1715  ONIXS_CONFLATEDTCP_NODISCARD
1716  ONIXS_CONFLATEDTCP_CONSTEXPR
1717  static const Char* className()
1718  {
1719  return "MarketDataRequest205";
1720  }
1721 
1722  /// FIX message type.
1723  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1724  ONIXS_CONFLATEDTCP_NODISCARD
1725  ONIXS_CONFLATEDTCP_CONSTEXPR
1726  static StrRef fixType()
1727  ONIXS_CONFLATEDTCP_NOTHROW
1728  {
1729  return constructStrRef("V ");
1730  }
1731 
1732  /// \return a human-readable presentation.
1733  ONIXS_CONFLATEDTCP_NODISCARD
1734  std::string toString() const;
1735 
1736  /// \return the end of the message.
1737  ONIXS_CONFLATEDTCP_NODISCARD
1738  const void* tail() const
1739  ONIXS_CONFLATEDTCP_NOTHROW
1740  {
1741  return
1742  relatedSym().tail();
1743  }
1744 
1745  /// \return the size occupied by the message.
1746  ONIXS_CONFLATEDTCP_NODISCARD
1747  EncodedLength calculateBinarySize() const
1748  ONIXS_CONFLATEDTCP_NOTHROW
1749  {
1750  return
1751  SbeMessage::calculateBinarySize(tail());
1752  }
1753 
1754 private:
1755  void checkLength(
1756  EncodedLength length, SchemaVersion version) const
1757  {
1758  const EncodedLength minimalRequiredLength =
1759  blockLength(version) +
1760  MessageHeader::Size +
1761  getMinimalVariableFieldsSize(version);
1762 
1763  checkBinaryLength(
1764  *this, length, minimalRequiredLength);
1765  }
1766 
1767  /// Checks variable fields consistency.
1768  void checkVarLenFields() const
1769  {
1770  groups().
1771  checkTail<SecurityGroups>().
1772  checkTail<RelatedSym>();
1773  }
1774 
1775  void checkCompatibility() const
1776  {
1777  assert(TemplateId == templateId());
1778 
1779  checkSchema<Schema>(schemaId(), version());
1780  checkLength(bufferSize(), version());
1781  checkVarLenFields();
1782  }
1783 
1784  /// Access helper.
1785  struct SecurityGroupsAccess
1786  {
1787  SecurityGroups
1788  operator()(
1789  const MarketDataRequest205& obj) const
1790  ONIXS_CONFLATEDTCP_NOTHROW
1791  {
1792  return obj.
1793  groups().
1794  head<SecurityGroups>();
1795  }
1796  };
1797 
1798  /// Reset an instance of the repeating group.
1799  /// All the following data will be invalidated.
1800  void setSecurityGroupsToNull()
1801  ONIXS_CONFLATEDTCP_NOTHROW
1802  {
1803  resetGroup<SecurityGroups>(
1804  SecurityGroupsAccess(),
1805  *this);
1806  }
1807 
1808  /// Access helper.
1809  struct RelatedSymAccess
1810  {
1811  RelatedSym
1812  operator()(
1813  const MarketDataRequest205& obj) const
1814  ONIXS_CONFLATEDTCP_NOTHROW
1815  {
1816  return obj.
1817  groups().
1818  tail<SecurityGroups>().
1819  head<RelatedSym>();
1820  }
1821  };
1822 
1823  /// Reset an instance of the repeating group.
1824  /// All the following data will be invalidated.
1825  void setRelatedSymToNull()
1826  ONIXS_CONFLATEDTCP_NOTHROW
1827  {
1828  resetGroup<RelatedSym>(
1829  RelatedSymAccess(),
1830  *this);
1831  }
1832 };
1833 
1834 /// RequestAck.
1835 ONIXS_CONFLATEDTCP_LTWT_STRUCT
1836 RequestAck206
1837 : SbeMessage
1838 {
1839  /// Used template schema.
1840  typedef SchemaTraits Schema;
1841 
1842  /// This type alias.
1843  typedef RequestAck206 ThisType;
1844 
1845  /// Message template ID from SBE schema.
1846  enum { TemplateId = 206 };
1847 
1848  /// Number of SecurityGroups acknowledged.
1849  /// Entry of SecurityGroupsEntry repeating group.
1850  ONIXS_CONFLATEDTCP_LTWT_STRUCT
1851  SecurityGroupsEntry : SbeGroupEntry
1852  <
1853  GroupSize::BlockLength
1854  >
1855  {
1856  /// Base class type.
1857  typedef
1858  SbeGroupEntry
1859  <
1860  GroupSize::BlockLength
1861  >
1862  Base;
1863 
1864  /// This type alias.
1865  typedef SecurityGroupsEntry ThisType;
1866 
1867  /// Initializes instance of given
1868  /// version over given memory block.
1869  SecurityGroupsEntry(
1870  void* data,
1871  EncodedLength length,
1872  SchemaVersion version)
1873  : Base(data, length, version)
1874  {
1875  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
1876  assert(length >= blockLength(version));
1877  }
1878 
1879  /// Reset all variable-length fields if any.
1880  ThisType& resetVariableFields()
1881  ONIXS_CONFLATEDTCP_NOTHROW
1882  {
1883  return *this;
1884  }
1885 
1886  /// Reset all variable-length and optional fields if any.
1887  ThisType& reset()
1888  ONIXS_CONFLATEDTCP_NOTHROW
1889  {
1890  resetVariableFields();
1891  return *this;
1892  }
1893 
1894  /// Security Group.
1895  ONIXS_CONFLATEDTCP_NODISCARD
1896  StrRef securityGroup() const
1897  ONIXS_CONFLATEDTCP_NOTHROW
1898  {
1899  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1900  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
1901 
1902  return fixedStr<length>(offset);
1903  }
1904 
1905  /// Security Group.
1906  ThisType& setSecurityGroup(StrRef value)
1907  ONIXS_CONFLATEDTCP_NOTHROW
1908  {
1909  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1910  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
1911 
1912  setFixedStr<length>(offset, value);
1913  return *this;
1914  }
1915 
1916  /// \return size of entry body in bytes
1917  /// for given version of message template.
1918  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1919  ONIXS_CONFLATEDTCP_CONSTEXPR
1920  static
1921  BlockLength
1922  blockLength(
1923  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
1924  ONIXS_CONFLATEDTCP_NOTHROW
1925  {
1926  return
1927  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
1928  6;
1929  }
1930 
1931  /// Entity class name.
1932  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
1933  ONIXS_CONFLATEDTCP_NODISCARD
1934  ONIXS_CONFLATEDTCP_CONSTEXPR
1935  static const Char* className()
1936  {
1937  return "RequestAck206.SecurityGroupsEntry";
1938  }
1939  };
1940 
1941  /// Repeating group containing SecurityGroupsEntry entries.
1942  typedef
1943  SbeGroup<SecurityGroupsEntry, GroupSize, MessageSize>
1944  SecurityGroups;
1945 
1946  /// Number of securities acknowledged.
1947  /// Entry of RelatedSymEntry repeating group.
1948  ONIXS_CONFLATEDTCP_LTWT_STRUCT
1949  RelatedSymEntry : SbeGroupEntry
1950  <
1951  GroupSize::BlockLength
1952  >
1953  {
1954  /// Base class type.
1955  typedef
1956  SbeGroupEntry
1957  <
1958  GroupSize::BlockLength
1959  >
1960  Base;
1961 
1962  /// This type alias.
1963  typedef RelatedSymEntry ThisType;
1964 
1965  /// Initializes instance of given
1966  /// version over given memory block.
1967  RelatedSymEntry(
1968  void* data,
1969  EncodedLength length,
1970  SchemaVersion version)
1971  : Base(data, length, version)
1972  {
1973  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
1974  assert(length >= blockLength(version));
1975  }
1976 
1977  /// Reset all variable-length fields if any.
1978  ThisType& resetVariableFields()
1979  ONIXS_CONFLATEDTCP_NOTHROW
1980  {
1981  return *this;
1982  }
1983 
1984  /// Reset all variable-length and optional fields if any.
1985  ThisType& reset()
1986  ONIXS_CONFLATEDTCP_NOTHROW
1987  {
1988  resetVariableFields();
1989  return *this;
1990  }
1991 
1992  /// Security ID.
1993  ONIXS_CONFLATEDTCP_NODISCARD
1994  Int32 securityId() const
1995  ONIXS_CONFLATEDTCP_NOTHROW
1996  {
1997  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
1998 
1999  return ordinary<Int32>(offset);
2000  }
2001 
2002  /// Security ID.
2003  ThisType& setSecurityId(Int32 value)
2004  ONIXS_CONFLATEDTCP_NOTHROW
2005  {
2006  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2007 
2008  setOrdinary(offset, value);
2009  return *this;
2010  }
2011 
2012  /// \return size of entry body in bytes
2013  /// for given version of message template.
2014  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2015  ONIXS_CONFLATEDTCP_CONSTEXPR
2016  static
2017  BlockLength
2018  blockLength(
2019  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
2020  ONIXS_CONFLATEDTCP_NOTHROW
2021  {
2022  return
2023  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2024  4;
2025  }
2026 
2027  /// Entity class name.
2028  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2029  ONIXS_CONFLATEDTCP_NODISCARD
2030  ONIXS_CONFLATEDTCP_CONSTEXPR
2031  static const Char* className()
2032  {
2033  return "RequestAck206.RelatedSymEntry";
2034  }
2035  };
2036 
2037  /// Repeating group containing RelatedSymEntry entries.
2038  typedef
2039  SbeGroup<RelatedSymEntry, GroupSize, MessageSize>
2040  RelatedSym;
2041 
2042  /// Initializes a blank instance.
2043  RequestAck206() ONIXS_CONFLATEDTCP_DEFAULT;
2044 
2045  /// Initializes an instance over the given memory block.
2046  RequestAck206(
2047  void* data,
2048  EncodedLength length,
2049  SchemaVersion version = Schema::Version)
2050  : SbeMessage(data, length, version)
2051  {
2052  checkVersion<Schema>(version);
2053  checkLength(length, version);
2054  initHeader(TemplateId, blockLength(version), Schema::Id);
2055  reset();
2056  }
2057 
2058  /// Initializes an instance over the given memory block
2059  /// With no variable-length fields initialization
2060  /// It is assumed that the user does such an initialization manually.
2061  RequestAck206(
2062  void* data,
2063  EncodedLength length,
2064  NoFieldsInit,
2065  SchemaVersion version = Schema::Version)
2066  : SbeMessage(data, length, version)
2067  {
2068  checkVersion<Schema>(version);
2069  checkLength(length, version);
2070  initHeader(TemplateId, blockLength(version), Schema::Id);
2071  resetVariableFields();
2072  }
2073 
2074  /// Initializes an instance over the given memory block.
2075  RequestAck206(
2076  void* data,
2077  EncodedLength length,
2078  NoInit)
2079  : SbeMessage(data, length)
2080  {
2081  checkCompatibility();
2082  }
2083 
2084  /// Initializes an instance over the given SBE message.
2085  explicit
2086  RequestAck206(
2087  const SbeMessage& message)
2088  : SbeMessage(message)
2089  {
2090  assert(message.valid());
2091 
2092  checkCompatibility();
2093  }
2094 
2095  /// Initializes an instance over the given memory block.
2096  /// Performs no checks.
2097  RequestAck206(
2098  void* data,
2099  EncodedLength length,
2100  NoInit,
2101  NoCheck)
2102  ONIXS_CONFLATEDTCP_NOTHROW
2103  : SbeMessage(data, length, NoCheck())
2104  {
2105  assert(schemaId() == Schema::Id);
2106  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
2107  assert(TemplateId == templateId());
2108  }
2109 
2110  /// Unique identifier for Market Data Request.
2111  ONIXS_CONFLATEDTCP_NODISCARD
2112  UInt32 reqId() const
2113  ONIXS_CONFLATEDTCP_NOTHROW
2114  {
2115  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2116 
2117  return ordinary<UInt32>(offset);
2118  }
2119 
2120  /// Unique identifier for Market Data Request.
2121  ThisType& setReqId(UInt32 value)
2122  ONIXS_CONFLATEDTCP_NOTHROW
2123  {
2124  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2125 
2126  setOrdinary(offset, value);
2127  return *this;
2128  }
2129 
2130  /// Subscription ReqType.
2131  ONIXS_CONFLATEDTCP_NODISCARD
2132  SubscriptionReqType::Enum
2133  subscriptionReqType() const
2134  ONIXS_CONFLATEDTCP_NOTHROW
2135  {
2136  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
2137 
2138  return enumeration<SubscriptionReqType>(offset);
2139  }
2140 
2141  /// Subscription ReqType.
2142  ThisType&
2143  setSubscriptionReqType(
2144  SubscriptionReqType::Enum value)
2145  ONIXS_CONFLATEDTCP_NOTHROW
2146  {
2147  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
2148 
2149  setEnumeration<SubscriptionReqType>(offset, value);
2150  return *this;
2151  }
2152 
2153  /// Status of the request acknowledgement.
2154  ONIXS_CONFLATEDTCP_NODISCARD
2155  RequestIDStatus::Enum reqIdStatus() const
2156  ONIXS_CONFLATEDTCP_NOTHROW
2157  {
2158  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 5;
2159 
2160  return enumeration<RequestIDStatus>(offset);
2161  }
2162 
2163  /// Status of the request acknowledgement.
2164  ThisType&
2165  setReqIdStatus(
2166  RequestIDStatus::Enum value)
2167  ONIXS_CONFLATEDTCP_NOTHROW
2168  {
2169  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 5;
2170 
2171  setEnumeration<RequestIDStatus>(offset, value);
2172  return *this;
2173  }
2174 
2175  /// \return instance of SecurityGroups repeating group.
2176  ONIXS_CONFLATEDTCP_NODISCARD
2177  SecurityGroups securityGroups() const
2178  ONIXS_CONFLATEDTCP_NOTHROW
2179  {
2180  return getGroup<SecurityGroups>(
2181  SecurityGroupsAccess(),
2182  *this);
2183  }
2184 
2185  /// \return instance of SecurityGroups repeating group.
2186  ONIXS_CONFLATEDTCP_NODISCARD
2187  SecurityGroups securityGroups()
2188  ONIXS_CONFLATEDTCP_NOTHROW
2189  {
2190  return getGroup<SecurityGroups>(
2191  SecurityGroupsAccess(),
2192  *this);
2193  }
2194 
2195  /// Setup repeating group with the given number of entries.
2196  /// Sets all optional fields of the group entries to null.
2197  /// \return NoSecurityGroups(37022) repeating group.
2198  SecurityGroups
2199  securityGroups(
2200  SecurityGroups::Size length)
2201  {
2202  return constructGroup<SecurityGroups>(
2203  SecurityGroupsAccess(),
2204  length,
2205  *this);
2206  }
2207 
2208  /// Setup repeating group with the given number of entries.
2209  /// \return NoSecurityGroups(37022) repeating group.
2210  SecurityGroups
2211  securityGroups(
2212  SecurityGroups::Size length,
2213  NoFieldsInit)
2214  {
2215  return setupGroup<SecurityGroups>(
2216  SecurityGroupsAccess(),
2217  length,
2218  *this);
2219  }
2220 
2221  /// \return instance of RelatedSym repeating group.
2222  ONIXS_CONFLATEDTCP_NODISCARD
2223  RelatedSym relatedSym() const
2224  ONIXS_CONFLATEDTCP_NOTHROW
2225  {
2226  return getGroup<RelatedSym>(
2227  RelatedSymAccess(),
2228  *this);
2229  }
2230 
2231  /// \return instance of RelatedSym repeating group.
2232  ONIXS_CONFLATEDTCP_NODISCARD
2233  RelatedSym relatedSym()
2234  ONIXS_CONFLATEDTCP_NOTHROW
2235  {
2236  return getGroup<RelatedSym>(
2237  RelatedSymAccess(),
2238  *this);
2239  }
2240 
2241  /// Setup repeating group with the given number of entries.
2242  /// Sets all optional fields of the group entries to null.
2243  /// \return NoRelatedSym(146) repeating group.
2244  RelatedSym relatedSym(RelatedSym::Size length)
2245  {
2246  return constructGroup<RelatedSym>(
2247  RelatedSymAccess(),
2248  length,
2249  *this);
2250  }
2251 
2252  /// Setup repeating group with the given number of entries.
2253  /// \return NoRelatedSym(146) repeating group.
2254  RelatedSym
2255  relatedSym(
2256  RelatedSym::Size length,
2257  NoFieldsInit)
2258  {
2259  return setupGroup<RelatedSym>(
2260  RelatedSymAccess(),
2261  length,
2262  *this);
2263  }
2264 
2265  /// Size of message body in bytes.
2266  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2267  ONIXS_CONFLATEDTCP_CONSTEXPR
2268  static
2269  BlockLength
2270  blockLength(
2271  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
2272  ONIXS_CONFLATEDTCP_NOTHROW
2273  {
2274  return
2275  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2276  6;
2277  }
2278 
2279  /// Minimal variable fields size (when variable-length fields are empty).
2280  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2281  ONIXS_CONFLATEDTCP_NODISCARD
2282  ONIXS_CONFLATEDTCP_CONSTEXPR
2283  static
2284  MessageSize
2285  getMinimalVariableFieldsSize(
2286  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
2287  {
2288  return
2289  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2290  SecurityGroups::EmptySize + RelatedSym::EmptySize;
2291  }
2292 
2293  /// Maximal message size.
2294  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2295  ONIXS_CONFLATEDTCP_NODISCARD
2296  ONIXS_CONFLATEDTCP_CONSTEXPR
2297  static
2298  UInt64
2299  getMaxMessageSize(
2300  UInt8 maxGroupItems = 255)
2301  ONIXS_CONFLATEDTCP_NOTHROW
2302  {
2303  return
2304  static_cast<UInt64>(MessageHeaderBuilder::Size) +
2305  blockLength(Schema::Version) +
2306  (GroupSize::Size + SecurityGroupsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems)) +
2307  (GroupSize::Size + RelatedSymEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
2308  }
2309 
2310  /// Reset all variable-length fields if any.
2311  ThisType& resetVariableFields()
2312  ONIXS_CONFLATEDTCP_NOTHROW
2313  {
2314  setSecurityGroupsToNull();
2315  setRelatedSymToNull();
2316  return *this;
2317  }
2318 
2319  /// Reset all variable-length and optional fields if any.
2320  ThisType& reset()
2321  ONIXS_CONFLATEDTCP_NOTHROW
2322  {
2323  resetVariableFields();
2324  return *this;
2325  }
2326 
2327  /// \return class name.
2328  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2329  ONIXS_CONFLATEDTCP_NODISCARD
2330  ONIXS_CONFLATEDTCP_CONSTEXPR
2331  static const Char* className()
2332  {
2333  return "RequestAck206";
2334  }
2335 
2336  /// FIX message type.
2337  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2338  ONIXS_CONFLATEDTCP_NODISCARD
2339  ONIXS_CONFLATEDTCP_CONSTEXPR
2340  static StrRef fixType()
2341  ONIXS_CONFLATEDTCP_NOTHROW
2342  {
2343  return constructStrRef("V");
2344  }
2345 
2346  /// \return a human-readable presentation.
2347  ONIXS_CONFLATEDTCP_NODISCARD
2348  std::string toString() const;
2349 
2350  /// \return the end of the message.
2351  ONIXS_CONFLATEDTCP_NODISCARD
2352  const void* tail() const
2353  ONIXS_CONFLATEDTCP_NOTHROW
2354  {
2355  return
2356  relatedSym().tail();
2357  }
2358 
2359  /// \return the size occupied by the message.
2360  ONIXS_CONFLATEDTCP_NODISCARD
2361  EncodedLength calculateBinarySize() const
2362  ONIXS_CONFLATEDTCP_NOTHROW
2363  {
2364  return
2365  SbeMessage::calculateBinarySize(tail());
2366  }
2367 
2368 private:
2369  void checkLength(
2370  EncodedLength length, SchemaVersion version) const
2371  {
2372  const EncodedLength minimalRequiredLength =
2373  blockLength(version) +
2374  MessageHeader::Size +
2375  getMinimalVariableFieldsSize(version);
2376 
2377  checkBinaryLength(
2378  *this, length, minimalRequiredLength);
2379  }
2380 
2381  /// Checks variable fields consistency.
2382  void checkVarLenFields() const
2383  {
2384  groups().
2385  checkTail<SecurityGroups>().
2386  checkTail<RelatedSym>();
2387  }
2388 
2389  void checkCompatibility() const
2390  {
2391  assert(TemplateId == templateId());
2392 
2393  checkSchema<Schema>(schemaId(), version());
2394  checkLength(bufferSize(), version());
2395  checkVarLenFields();
2396  }
2397 
2398  /// Access helper.
2399  struct SecurityGroupsAccess
2400  {
2401  SecurityGroups operator()(const RequestAck206& obj) const
2402  ONIXS_CONFLATEDTCP_NOTHROW
2403  {
2404  return obj.
2405  groups().
2406  head<SecurityGroups>();
2407  }
2408  };
2409 
2410  /// Reset an instance of the repeating group.
2411  /// All the following data will be invalidated.
2412  void setSecurityGroupsToNull()
2413  ONIXS_CONFLATEDTCP_NOTHROW
2414  {
2415  resetGroup<SecurityGroups>(
2416  SecurityGroupsAccess(),
2417  *this);
2418  }
2419 
2420  /// Access helper.
2421  struct RelatedSymAccess
2422  {
2423  RelatedSym operator()(const RequestAck206& obj) const
2424  ONIXS_CONFLATEDTCP_NOTHROW
2425  {
2426  return obj.
2427  groups().
2428  tail<SecurityGroups>().
2429  head<RelatedSym>();
2430  }
2431  };
2432 
2433  /// Reset an instance of the repeating group.
2434  /// All the following data will be invalidated.
2435  void setRelatedSymToNull()
2436  ONIXS_CONFLATEDTCP_NOTHROW
2437  {
2438  resetGroup<RelatedSym>(
2439  RelatedSymAccess(),
2440  *this);
2441  }
2442 };
2443 
2444 /// RequestReject.
2445 ONIXS_CONFLATEDTCP_LTWT_STRUCT
2446 RequestReject207
2447 : SbeMessage
2448 {
2449  /// Used template schema.
2450  typedef SchemaTraits Schema;
2451 
2452  /// This type alias.
2453  typedef RequestReject207 ThisType;
2454 
2455  /// Message template ID from SBE schema.
2456  enum { TemplateId = 207 };
2457 
2458  /// Initializes a blank instance.
2459  RequestReject207() ONIXS_CONFLATEDTCP_DEFAULT;
2460 
2461  /// Initializes an instance over the given memory block.
2462  RequestReject207(
2463  void* data,
2464  EncodedLength length,
2465  SchemaVersion version = Schema::Version)
2466  : SbeMessage(data, length, version)
2467  {
2468  checkVersion<Schema>(version);
2469  checkLength(length, version);
2470  initHeader(TemplateId, blockLength(version), Schema::Id);
2471  reset();
2472  }
2473 
2474  /// Initializes an instance over the given memory block
2475  /// With no variable-length fields initialization
2476  /// It is assumed that the user does such an initialization manually.
2477  RequestReject207(
2478  void* data,
2479  EncodedLength length,
2480  NoFieldsInit,
2481  SchemaVersion version = Schema::Version)
2482  : SbeMessage(data, length, version)
2483  {
2484  checkVersion<Schema>(version);
2485  checkLength(length, version);
2486  initHeader(TemplateId, blockLength(version), Schema::Id);
2487  resetVariableFields();
2488  }
2489 
2490  /// Initializes an instance over the given memory block.
2491  RequestReject207(
2492  void* data,
2493  EncodedLength length,
2494  NoInit)
2495  : SbeMessage(data, length)
2496  {
2497  checkCompatibility();
2498  }
2499 
2500  /// Initializes an instance over the given SBE message.
2501  explicit
2502  RequestReject207(
2503  const SbeMessage& message)
2504  : SbeMessage(message)
2505  {
2506  assert(message.valid());
2507 
2508  checkCompatibility();
2509  }
2510 
2511  /// Initializes an instance over the given memory block.
2512  /// Performs no checks.
2513  RequestReject207(
2514  void* data,
2515  EncodedLength length,
2516  NoInit,
2517  NoCheck)
2518  ONIXS_CONFLATEDTCP_NOTHROW
2519  : SbeMessage(data, length, NoCheck())
2520  {
2521  assert(schemaId() == Schema::Id);
2522  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
2523  assert(TemplateId == templateId());
2524  }
2525 
2526  /// Unique identifier for Market Data Request.
2527  ONIXS_CONFLATEDTCP_NODISCARD
2528  bool reqId(UInt32& value) const
2529  ONIXS_CONFLATEDTCP_NOTHROW
2530  {
2531  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2532 
2533  return ordinary(value, offset, NullUInt32());
2534  }
2535 
2536  /// Unique identifier for Market Data Request.
2537  ThisType& setReqId(UInt32 value)
2538  ONIXS_CONFLATEDTCP_NOTHROW
2539  {
2540  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2541 
2542  setOrdinary(offset, value);
2543  return *this;
2544  }
2545 
2546  ThisType& setReqIdToNull()
2547  ONIXS_CONFLATEDTCP_NOTHROW
2548  {
2549  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2550 
2551  setOrdinary(offset, NullUInt32());
2552  return *this;
2553  }
2554 
2555  /// Market Data Request Reject reason code.
2556  ONIXS_CONFLATEDTCP_NODISCARD
2557  ReqRejReason::Enum reqRejReason() const
2558  ONIXS_CONFLATEDTCP_NOTHROW
2559  {
2560  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
2561 
2562  return enumeration<ReqRejReason>(offset);
2563  }
2564 
2565  /// Market Data Request Reject reason code.
2566  ThisType& setReqRejReason(ReqRejReason::Enum value)
2567  ONIXS_CONFLATEDTCP_NOTHROW
2568  {
2569  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
2570 
2571  setEnumeration<ReqRejReason>(offset, value);
2572  return *this;
2573  }
2574 
2575  /// Reject reason details.
2576  ONIXS_CONFLATEDTCP_NODISCARD
2577  StrRef text() const
2578  ONIXS_CONFLATEDTCP_NOTHROW
2579  {
2580  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 5;
2581  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 100;
2582 
2583  return fixedStr<length>(offset);
2584  }
2585 
2586  /// Reject reason details.
2587  ThisType& setText(StrRef value)
2588  ONIXS_CONFLATEDTCP_NOTHROW
2589  {
2590  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 5;
2591  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 100;
2592 
2593  setFixedStr<length>(offset, value);
2594  return *this;
2595  }
2596 
2597  /// Size of message body in bytes.
2598  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2599  ONIXS_CONFLATEDTCP_CONSTEXPR
2600  static
2601  BlockLength
2602  blockLength(
2603  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
2604  ONIXS_CONFLATEDTCP_NOTHROW
2605  {
2606  return
2607  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2608  105;
2609  }
2610 
2611  /// Minimal variable fields size (when variable-length fields are empty).
2612  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2613  ONIXS_CONFLATEDTCP_NODISCARD
2614  ONIXS_CONFLATEDTCP_CONSTEXPR
2615  static
2616  MessageSize
2617  getMinimalVariableFieldsSize(
2618  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
2619  {
2620  return
2621  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2622  0;
2623  }
2624 
2625  /// Maximal message size.
2626  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2627  ONIXS_CONFLATEDTCP_NODISCARD
2628  ONIXS_CONFLATEDTCP_CONSTEXPR
2629  static UInt64 getMaxMessageSize(UInt8)
2630  ONIXS_CONFLATEDTCP_NOTHROW
2631  {
2632  return
2633  static_cast<UInt64>(MessageHeaderBuilder::Size) +
2634  blockLength(Schema::Version);
2635  }
2636 
2637  /// Reset all variable-length fields if any.
2638  ThisType& resetVariableFields()
2639  ONIXS_CONFLATEDTCP_NOTHROW
2640  {
2641  return *this;
2642  }
2643 
2644  /// Reset all variable-length and optional fields if any.
2645  ThisType& reset()
2646  ONIXS_CONFLATEDTCP_NOTHROW
2647  {
2648  setReqIdToNull();
2649 
2650  resetVariableFields();
2651  return *this;
2652  }
2653 
2654  /// \return class name.
2655  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2656  ONIXS_CONFLATEDTCP_NODISCARD
2657  ONIXS_CONFLATEDTCP_CONSTEXPR
2658  static const Char* className()
2659  {
2660  return "RequestReject207";
2661  }
2662 
2663  /// FIX message type.
2664  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2665  ONIXS_CONFLATEDTCP_NODISCARD
2666  ONIXS_CONFLATEDTCP_CONSTEXPR
2667  static StrRef fixType()
2668  ONIXS_CONFLATEDTCP_NOTHROW
2669  {
2670  return constructStrRef("Y");
2671  }
2672 
2673  /// \return a human-readable presentation.
2674  ONIXS_CONFLATEDTCP_NODISCARD
2675  std::string toString() const;
2676 
2677  /// \return the end of the message.
2678  ONIXS_CONFLATEDTCP_NODISCARD
2679  const void* tail() const
2680  ONIXS_CONFLATEDTCP_NOTHROW
2681  {
2682  return
2683  toOpaquePtr(
2684  advanceByBytes(
2685  binary(),
2686  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
2687  MessageHeader::Size));
2688  }
2689 
2690  /// \return the size occupied by the message.
2691  ONIXS_CONFLATEDTCP_NODISCARD
2692  EncodedLength calculateBinarySize() const
2693  ONIXS_CONFLATEDTCP_NOTHROW
2694  {
2695  return
2696  SbeMessage::calculateBinarySize(tail());
2697  }
2698 
2699 private:
2700  void checkLength(
2701  EncodedLength length, SchemaVersion version) const
2702  {
2703  const EncodedLength minimalRequiredLength =
2704  blockLength(version) +
2705  MessageHeader::Size +
2706  getMinimalVariableFieldsSize(version);
2707 
2708  checkBinaryLength(
2709  *this, length, minimalRequiredLength);
2710  }
2711 
2712  void checkCompatibility() const
2713  {
2714  assert(TemplateId == templateId());
2715 
2716  checkSchema<Schema>(schemaId(), version());
2717  checkLength(bufferSize(), version());
2718  }
2719 };
2720 
2721 /// SecurityListRequest.
2722 ONIXS_CONFLATEDTCP_LTWT_STRUCT
2723 SecurityListRequest208
2724 : SbeMessage
2725 {
2726  /// Used template schema.
2727  typedef SchemaTraits Schema;
2728 
2729  /// This type alias.
2730  typedef SecurityListRequest208 ThisType;
2731 
2732  /// Message template ID from SBE schema.
2733  enum { TemplateId = 208 };
2734 
2735  /// Number of SecurityGroups specified in subscription
2736  /// request. Should be equal 0, when subscription is requested
2737  /// for all groups on the segment or individual Security IDs
2738  /// are listed in the criteria for subscription.
2739  /// Entry of SecurityGroupsEntry repeating group.
2740  ONIXS_CONFLATEDTCP_LTWT_STRUCT
2741  SecurityGroupsEntry : SbeGroupEntry
2742  <
2743  GroupSize::BlockLength
2744  >
2745  {
2746  /// Base class type.
2747  typedef
2748  SbeGroupEntry
2749  <
2750  GroupSize::BlockLength
2751  >
2752  Base;
2753 
2754  /// This type alias.
2755  typedef SecurityGroupsEntry ThisType;
2756 
2757  /// Initializes instance of given
2758  /// version over given memory block.
2759  SecurityGroupsEntry(
2760  void* data,
2761  EncodedLength length,
2762  SchemaVersion version)
2763  : Base(data, length, version)
2764  {
2765  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
2766  assert(length >= blockLength(version));
2767  }
2768 
2769  /// Reset all variable-length fields if any.
2770  ThisType& resetVariableFields()
2771  ONIXS_CONFLATEDTCP_NOTHROW
2772  {
2773  return *this;
2774  }
2775 
2776  /// Reset all variable-length and optional fields if any.
2777  ThisType& reset()
2778  ONIXS_CONFLATEDTCP_NOTHROW
2779  {
2780  resetVariableFields();
2781  return *this;
2782  }
2783 
2784  /// Security Group.
2785  ONIXS_CONFLATEDTCP_NODISCARD
2786  StrRef securityGroup() const
2787  ONIXS_CONFLATEDTCP_NOTHROW
2788  {
2789  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2790  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
2791 
2792  return fixedStr<length>(offset);
2793  }
2794 
2795  /// Security Group.
2796  ThisType& setSecurityGroup(StrRef value)
2797  ONIXS_CONFLATEDTCP_NOTHROW
2798  {
2799  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2800  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
2801 
2802  setFixedStr<length>(offset, value);
2803  return *this;
2804  }
2805 
2806  /// \return size of entry body in bytes
2807  /// for given version of message template.
2808  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2809  ONIXS_CONFLATEDTCP_CONSTEXPR
2810  static
2811  BlockLength
2812  blockLength(
2813  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
2814  ONIXS_CONFLATEDTCP_NOTHROW
2815  {
2816  return
2817  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2818  6;
2819  }
2820 
2821  /// Entity class name.
2822  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2823  ONIXS_CONFLATEDTCP_NODISCARD
2824  ONIXS_CONFLATEDTCP_CONSTEXPR
2825  static const Char* className()
2826  {
2827  return "SecurityListRequest208.SecurityGroupsEntry";
2828  }
2829  };
2830 
2831  /// Repeating group containing SecurityGroupsEntry entries.
2832  typedef
2833  SbeGroup<SecurityGroupsEntry, GroupSize, MessageSize>
2834  SecurityGroups;
2835 
2836  /// Number of instruments requested. When NoSecurityGroups > 0
2837  /// specified in the request, the NoRelatedSym should be
2838  /// equal 0.
2839  /// Entry of RelatedSymEntry repeating group.
2840  ONIXS_CONFLATEDTCP_LTWT_STRUCT
2841  RelatedSymEntry : SbeGroupEntry
2842  <
2843  GroupSize::BlockLength
2844  >
2845  {
2846  /// Base class type.
2847  typedef
2848  SbeGroupEntry
2849  <
2850  GroupSize::BlockLength
2851  >
2852  Base;
2853 
2854  /// This type alias.
2855  typedef RelatedSymEntry ThisType;
2856 
2857  /// Initializes instance of given
2858  /// version over given memory block.
2859  RelatedSymEntry(
2860  void* data,
2861  EncodedLength length,
2862  SchemaVersion version)
2863  : Base(data, length, version)
2864  {
2865  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
2866  assert(length >= blockLength(version));
2867  }
2868 
2869  /// Reset all variable-length fields if any.
2870  ThisType& resetVariableFields()
2871  ONIXS_CONFLATEDTCP_NOTHROW
2872  {
2873  return *this;
2874  }
2875 
2876  /// Reset all variable-length and optional fields if any.
2877  ThisType& reset()
2878  ONIXS_CONFLATEDTCP_NOTHROW
2879  {
2880  resetVariableFields();
2881  return *this;
2882  }
2883 
2884  /// Security ID.
2885  ONIXS_CONFLATEDTCP_NODISCARD
2886  Int32 securityId() const
2887  ONIXS_CONFLATEDTCP_NOTHROW
2888  {
2889  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2890 
2891  return ordinary<Int32>(offset);
2892  }
2893 
2894  /// Security ID.
2895  ThisType& setSecurityId(Int32 value)
2896  ONIXS_CONFLATEDTCP_NOTHROW
2897  {
2898  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
2899 
2900  setOrdinary(offset, value);
2901  return *this;
2902  }
2903 
2904  /// \return size of entry body in bytes
2905  /// for given version of message template.
2906  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2907  ONIXS_CONFLATEDTCP_CONSTEXPR
2908  static
2909  BlockLength
2910  blockLength(
2911  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
2912  ONIXS_CONFLATEDTCP_NOTHROW
2913  {
2914  return
2915  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
2916  4;
2917  }
2918 
2919  /// Entity class name.
2920  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
2921  ONIXS_CONFLATEDTCP_NODISCARD
2922  ONIXS_CONFLATEDTCP_CONSTEXPR
2923  static const Char* className()
2924  {
2925  return "SecurityListRequest208.RelatedSymEntry";
2926  }
2927  };
2928 
2929  /// Repeating group containing RelatedSymEntry entries.
2930  typedef
2931  SbeGroup<RelatedSymEntry, GroupSize, MessageSize>
2932  RelatedSym;
2933 
2934  /// Initializes a blank instance.
2935  SecurityListRequest208() ONIXS_CONFLATEDTCP_DEFAULT;
2936 
2937  /// Initializes an instance over the given memory block.
2938  SecurityListRequest208(
2939  void* data,
2940  EncodedLength length,
2941  SchemaVersion version = Schema::Version)
2942  : SbeMessage(data, length, version)
2943  {
2944  checkVersion<Schema>(version);
2945  checkLength(length, version);
2946  initHeader(TemplateId, blockLength(version), Schema::Id);
2947  reset();
2948  }
2949 
2950  /// Initializes an instance over the given memory block
2951  /// With no variable-length fields initialization
2952  /// It is assumed that the user does such an initialization manually.
2953  SecurityListRequest208(
2954  void* data,
2955  EncodedLength length,
2956  NoFieldsInit,
2957  SchemaVersion version = Schema::Version)
2958  : SbeMessage(data, length, version)
2959  {
2960  checkVersion<Schema>(version);
2961  checkLength(length, version);
2962  initHeader(TemplateId, blockLength(version), Schema::Id);
2963  resetVariableFields();
2964  }
2965 
2966  /// Initializes an instance over the given memory block.
2967  SecurityListRequest208(
2968  void* data,
2969  EncodedLength length,
2970  NoInit)
2971  : SbeMessage(data, length)
2972  {
2973  checkCompatibility();
2974  }
2975 
2976  /// Initializes an instance over the given SBE message.
2977  explicit
2978  SecurityListRequest208(
2979  const SbeMessage& message)
2980  : SbeMessage(message)
2981  {
2982  assert(message.valid());
2983 
2984  checkCompatibility();
2985  }
2986 
2987  /// Initializes an instance over the given memory block.
2988  /// Performs no checks.
2989  SecurityListRequest208(
2990  void* data,
2991  EncodedLength length,
2992  NoInit,
2993  NoCheck)
2994  ONIXS_CONFLATEDTCP_NOTHROW
2995  : SbeMessage(data, length, NoCheck())
2996  {
2997  assert(schemaId() == Schema::Id);
2998  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
2999  assert(TemplateId == templateId());
3000  }
3001 
3002  /// Unique identifier of the Request. Must be unique per
3003  /// session so it can be referenced in Request Acknowledgment
3004  /// or Request Reject responses from the exchange.
3005  ONIXS_CONFLATEDTCP_NODISCARD
3006  UInt32 reqId() const
3007  ONIXS_CONFLATEDTCP_NOTHROW
3008  {
3009  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3010 
3011  return ordinary<UInt32>(offset);
3012  }
3013 
3014  /// Unique identifier of the Request. Must be unique per
3015  /// session so it can be referenced in Request Acknowledgment
3016  /// or Request Reject responses from the exchange.
3017  ThisType& setReqId(UInt32 value)
3018  ONIXS_CONFLATEDTCP_NOTHROW
3019  {
3020  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3021 
3022  setOrdinary(offset, value);
3023  return *this;
3024  }
3025 
3026  /// Subscription Request Type indicates to the type of
3027  /// response expected.
3028  ONIXS_CONFLATEDTCP_NODISCARD
3029  SubscriptionReqType::Enum
3030  subscriptionReqType() const
3031  ONIXS_CONFLATEDTCP_NOTHROW
3032  {
3033  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
3034 
3035  return enumeration<SubscriptionReqType>(offset);
3036  }
3037 
3038  /// Subscription Request Type indicates to the type of
3039  /// response expected.
3040  ThisType&
3041  setSubscriptionReqType(
3042  SubscriptionReqType::Enum value)
3043  ONIXS_CONFLATEDTCP_NOTHROW
3044  {
3045  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
3046 
3047  setEnumeration<SubscriptionReqType>(offset, value);
3048  return *this;
3049  }
3050 
3051  /// \return instance of SecurityGroups repeating group.
3052  ONIXS_CONFLATEDTCP_NODISCARD
3053  SecurityGroups securityGroups() const
3054  ONIXS_CONFLATEDTCP_NOTHROW
3055  {
3056  return getGroup<SecurityGroups>(
3057  SecurityGroupsAccess(),
3058  *this);
3059  }
3060 
3061  /// \return instance of SecurityGroups repeating group.
3062  ONIXS_CONFLATEDTCP_NODISCARD
3063  SecurityGroups securityGroups()
3064  ONIXS_CONFLATEDTCP_NOTHROW
3065  {
3066  return getGroup<SecurityGroups>(
3067  SecurityGroupsAccess(),
3068  *this);
3069  }
3070 
3071  /// Setup repeating group with the given number of entries.
3072  /// Sets all optional fields of the group entries to null.
3073  /// \return NoSecurityGroups(37022) repeating group.
3074  SecurityGroups
3075  securityGroups(
3076  SecurityGroups::Size length)
3077  {
3078  return constructGroup<SecurityGroups>(
3079  SecurityGroupsAccess(),
3080  length,
3081  *this);
3082  }
3083 
3084  /// Setup repeating group with the given number of entries.
3085  /// \return NoSecurityGroups(37022) repeating group.
3086  SecurityGroups
3087  securityGroups(
3088  SecurityGroups::Size length,
3089  NoFieldsInit)
3090  {
3091  return setupGroup<SecurityGroups>(
3092  SecurityGroupsAccess(),
3093  length,
3094  *this);
3095  }
3096 
3097  /// \return instance of RelatedSym repeating group.
3098  ONIXS_CONFLATEDTCP_NODISCARD
3099  RelatedSym relatedSym() const
3100  ONIXS_CONFLATEDTCP_NOTHROW
3101  {
3102  return getGroup<RelatedSym>(
3103  RelatedSymAccess(),
3104  *this);
3105  }
3106 
3107  /// \return instance of RelatedSym repeating group.
3108  ONIXS_CONFLATEDTCP_NODISCARD
3109  RelatedSym relatedSym()
3110  ONIXS_CONFLATEDTCP_NOTHROW
3111  {
3112  return getGroup<RelatedSym>(
3113  RelatedSymAccess(),
3114  *this);
3115  }
3116 
3117  /// Setup repeating group with the given number of entries.
3118  /// Sets all optional fields of the group entries to null.
3119  /// \return NoRelatedSym(146) repeating group.
3120  RelatedSym relatedSym(RelatedSym::Size length)
3121  {
3122  return constructGroup<RelatedSym>(
3123  RelatedSymAccess(),
3124  length,
3125  *this);
3126  }
3127 
3128  /// Setup repeating group with the given number of entries.
3129  /// \return NoRelatedSym(146) repeating group.
3130  RelatedSym
3131  relatedSym(
3132  RelatedSym::Size length,
3133  NoFieldsInit)
3134  {
3135  return setupGroup<RelatedSym>(
3136  RelatedSymAccess(),
3137  length,
3138  *this);
3139  }
3140 
3141  /// Size of message body in bytes.
3142  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3143  ONIXS_CONFLATEDTCP_CONSTEXPR
3144  static
3145  BlockLength
3146  blockLength(
3147  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
3148  ONIXS_CONFLATEDTCP_NOTHROW
3149  {
3150  return
3151  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3152  5;
3153  }
3154 
3155  /// Minimal variable fields size (when variable-length fields are empty).
3156  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3157  ONIXS_CONFLATEDTCP_NODISCARD
3158  ONIXS_CONFLATEDTCP_CONSTEXPR
3159  static
3160  MessageSize
3161  getMinimalVariableFieldsSize(
3162  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
3163  {
3164  return
3165  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3166  SecurityGroups::EmptySize + RelatedSym::EmptySize;
3167  }
3168 
3169  /// Maximal message size.
3170  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3171  ONIXS_CONFLATEDTCP_NODISCARD
3172  ONIXS_CONFLATEDTCP_CONSTEXPR
3173  static
3174  UInt64
3175  getMaxMessageSize(
3176  UInt8 maxGroupItems = 255)
3177  ONIXS_CONFLATEDTCP_NOTHROW
3178  {
3179  return
3180  static_cast<UInt64>(MessageHeaderBuilder::Size) +
3181  blockLength(Schema::Version) +
3182  (GroupSize::Size + SecurityGroupsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems)) +
3183  (GroupSize::Size + RelatedSymEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
3184  }
3185 
3186  /// Reset all variable-length fields if any.
3187  ThisType& resetVariableFields()
3188  ONIXS_CONFLATEDTCP_NOTHROW
3189  {
3190  setSecurityGroupsToNull();
3191  setRelatedSymToNull();
3192  return *this;
3193  }
3194 
3195  /// Reset all variable-length and optional fields if any.
3196  ThisType& reset()
3197  ONIXS_CONFLATEDTCP_NOTHROW
3198  {
3199  resetVariableFields();
3200  return *this;
3201  }
3202 
3203  /// \return class name.
3204  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3205  ONIXS_CONFLATEDTCP_NODISCARD
3206  ONIXS_CONFLATEDTCP_CONSTEXPR
3207  static const Char* className()
3208  {
3209  return "SecurityListRequest208";
3210  }
3211 
3212  /// FIX message type.
3213  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3214  ONIXS_CONFLATEDTCP_NODISCARD
3215  ONIXS_CONFLATEDTCP_CONSTEXPR
3216  static StrRef fixType()
3217  ONIXS_CONFLATEDTCP_NOTHROW
3218  {
3219  return constructStrRef("x ");
3220  }
3221 
3222  /// \return a human-readable presentation.
3223  ONIXS_CONFLATEDTCP_NODISCARD
3224  std::string toString() const;
3225 
3226  /// \return the end of the message.
3227  ONIXS_CONFLATEDTCP_NODISCARD
3228  const void* tail() const
3229  ONIXS_CONFLATEDTCP_NOTHROW
3230  {
3231  return
3232  relatedSym().tail();
3233  }
3234 
3235  /// \return the size occupied by the message.
3236  ONIXS_CONFLATEDTCP_NODISCARD
3237  EncodedLength calculateBinarySize() const
3238  ONIXS_CONFLATEDTCP_NOTHROW
3239  {
3240  return
3241  SbeMessage::calculateBinarySize(tail());
3242  }
3243 
3244 private:
3245  void checkLength(
3246  EncodedLength length, SchemaVersion version) const
3247  {
3248  const EncodedLength minimalRequiredLength =
3249  blockLength(version) +
3250  MessageHeader::Size +
3251  getMinimalVariableFieldsSize(version);
3252 
3253  checkBinaryLength(
3254  *this, length, minimalRequiredLength);
3255  }
3256 
3257  /// Checks variable fields consistency.
3258  void checkVarLenFields() const
3259  {
3260  groups().
3261  checkTail<SecurityGroups>().
3262  checkTail<RelatedSym>();
3263  }
3264 
3265  void checkCompatibility() const
3266  {
3267  assert(TemplateId == templateId());
3268 
3269  checkSchema<Schema>(schemaId(), version());
3270  checkLength(bufferSize(), version());
3271  checkVarLenFields();
3272  }
3273 
3274  /// Access helper.
3275  struct SecurityGroupsAccess
3276  {
3277  SecurityGroups
3278  operator()(
3279  const SecurityListRequest208& obj) const
3280  ONIXS_CONFLATEDTCP_NOTHROW
3281  {
3282  return obj.
3283  groups().
3284  head<SecurityGroups>();
3285  }
3286  };
3287 
3288  /// Reset an instance of the repeating group.
3289  /// All the following data will be invalidated.
3290  void setSecurityGroupsToNull()
3291  ONIXS_CONFLATEDTCP_NOTHROW
3292  {
3293  resetGroup<SecurityGroups>(
3294  SecurityGroupsAccess(),
3295  *this);
3296  }
3297 
3298  /// Access helper.
3299  struct RelatedSymAccess
3300  {
3301  RelatedSym
3302  operator()(
3303  const SecurityListRequest208& obj) const
3304  ONIXS_CONFLATEDTCP_NOTHROW
3305  {
3306  return obj.
3307  groups().
3308  tail<SecurityGroups>().
3309  head<RelatedSym>();
3310  }
3311  };
3312 
3313  /// Reset an instance of the repeating group.
3314  /// All the following data will be invalidated.
3315  void setRelatedSymToNull()
3316  ONIXS_CONFLATEDTCP_NOTHROW
3317  {
3318  resetGroup<RelatedSym>(
3319  RelatedSymAccess(),
3320  *this);
3321  }
3322 };
3323 
3324 /// SecurityStatusRequest.
3325 ONIXS_CONFLATEDTCP_LTWT_STRUCT
3326 SecurityStatusRequest209
3327 : SbeMessage
3328 {
3329  /// Used template schema.
3330  typedef SchemaTraits Schema;
3331 
3332  /// This type alias.
3333  typedef SecurityStatusRequest209 ThisType;
3334 
3335  /// Message template ID from SBE schema.
3336  enum { TemplateId = 209 };
3337 
3338  /// Number of SecurityGroups specified in subscription
3339  /// request. Should be equal 0, when subscription is requested
3340  /// for all groups on the segment or individual Security IDs
3341  /// are listed in the criteria for subscription.
3342  /// Entry of SecurityGroupsEntry repeating group.
3343  ONIXS_CONFLATEDTCP_LTWT_STRUCT
3344  SecurityGroupsEntry : SbeGroupEntry
3345  <
3346  GroupSize::BlockLength
3347  >
3348  {
3349  /// Base class type.
3350  typedef
3351  SbeGroupEntry
3352  <
3353  GroupSize::BlockLength
3354  >
3355  Base;
3356 
3357  /// This type alias.
3358  typedef SecurityGroupsEntry ThisType;
3359 
3360  /// Initializes instance of given
3361  /// version over given memory block.
3362  SecurityGroupsEntry(
3363  void* data,
3364  EncodedLength length,
3365  SchemaVersion version)
3366  : Base(data, length, version)
3367  {
3368  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
3369  assert(length >= blockLength(version));
3370  }
3371 
3372  /// Reset all variable-length fields if any.
3373  ThisType& resetVariableFields()
3374  ONIXS_CONFLATEDTCP_NOTHROW
3375  {
3376  return *this;
3377  }
3378 
3379  /// Reset all variable-length and optional fields if any.
3380  ThisType& reset()
3381  ONIXS_CONFLATEDTCP_NOTHROW
3382  {
3383  resetVariableFields();
3384  return *this;
3385  }
3386 
3387  /// Security Group.
3388  ONIXS_CONFLATEDTCP_NODISCARD
3389  StrRef securityGroup() const
3390  ONIXS_CONFLATEDTCP_NOTHROW
3391  {
3392  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3393  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
3394 
3395  return fixedStr<length>(offset);
3396  }
3397 
3398  /// Security Group.
3399  ThisType& setSecurityGroup(StrRef value)
3400  ONIXS_CONFLATEDTCP_NOTHROW
3401  {
3402  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3403  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength length = 6;
3404 
3405  setFixedStr<length>(offset, value);
3406  return *this;
3407  }
3408 
3409  /// \return size of entry body in bytes
3410  /// for given version of message template.
3411  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3412  ONIXS_CONFLATEDTCP_CONSTEXPR
3413  static
3414  BlockLength
3415  blockLength(
3416  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
3417  ONIXS_CONFLATEDTCP_NOTHROW
3418  {
3419  return
3420  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3421  6;
3422  }
3423 
3424  /// Entity class name.
3425  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3426  ONIXS_CONFLATEDTCP_NODISCARD
3427  ONIXS_CONFLATEDTCP_CONSTEXPR
3428  static const Char* className()
3429  {
3430  return "SecurityStatusRequest209.SecurityGroupsEntry";
3431  }
3432  };
3433 
3434  /// Repeating group containing SecurityGroupsEntry entries.
3435  typedef
3436  SbeGroup<SecurityGroupsEntry, GroupSize, MessageSize>
3437  SecurityGroups;
3438 
3439  /// Number of instruments requested. When NoSecurityGroups > 0
3440  /// specified in the request, the NoRelatedSym should be
3441  /// equal 0.
3442  /// Entry of RelatedSymEntry repeating group.
3443  ONIXS_CONFLATEDTCP_LTWT_STRUCT
3444  RelatedSymEntry : SbeGroupEntry
3445  <
3446  GroupSize::BlockLength
3447  >
3448  {
3449  /// Base class type.
3450  typedef
3451  SbeGroupEntry
3452  <
3453  GroupSize::BlockLength
3454  >
3455  Base;
3456 
3457  /// This type alias.
3458  typedef RelatedSymEntry ThisType;
3459 
3460  /// Initializes instance of given
3461  /// version over given memory block.
3462  RelatedSymEntry(
3463  void* data,
3464  EncodedLength length,
3465  SchemaVersion version)
3466  : Base(data, length, version)
3467  {
3468  assert(static_cast<Int16>(version) >= Schema::MinimalVersion);
3469  assert(length >= blockLength(version));
3470  }
3471 
3472  /// Reset all variable-length fields if any.
3473  ThisType& resetVariableFields()
3474  ONIXS_CONFLATEDTCP_NOTHROW
3475  {
3476  return *this;
3477  }
3478 
3479  /// Reset all variable-length and optional fields if any.
3480  ThisType& reset()
3481  ONIXS_CONFLATEDTCP_NOTHROW
3482  {
3483  resetVariableFields();
3484  return *this;
3485  }
3486 
3487  /// Security ID.
3488  ONIXS_CONFLATEDTCP_NODISCARD
3489  Int32 securityId() const
3490  ONIXS_CONFLATEDTCP_NOTHROW
3491  {
3492  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3493 
3494  return ordinary<Int32>(offset);
3495  }
3496 
3497  /// Security ID.
3498  ThisType& setSecurityId(Int32 value)
3499  ONIXS_CONFLATEDTCP_NOTHROW
3500  {
3501  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3502 
3503  setOrdinary(offset, value);
3504  return *this;
3505  }
3506 
3507  /// \return size of entry body in bytes
3508  /// for given version of message template.
3509  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3510  ONIXS_CONFLATEDTCP_CONSTEXPR
3511  static
3512  BlockLength
3513  blockLength(
3514  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
3515  ONIXS_CONFLATEDTCP_NOTHROW
3516  {
3517  return
3518  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3519  4;
3520  }
3521 
3522  /// Entity class name.
3523  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3524  ONIXS_CONFLATEDTCP_NODISCARD
3525  ONIXS_CONFLATEDTCP_CONSTEXPR
3526  static const Char* className()
3527  {
3528  return "SecurityStatusRequest209.RelatedSymEntry";
3529  }
3530  };
3531 
3532  /// Repeating group containing RelatedSymEntry entries.
3533  typedef
3534  SbeGroup<RelatedSymEntry, GroupSize, MessageSize>
3535  RelatedSym;
3536 
3537  /// Initializes a blank instance.
3538  SecurityStatusRequest209() ONIXS_CONFLATEDTCP_DEFAULT;
3539 
3540  /// Initializes an instance over the given memory block.
3541  SecurityStatusRequest209(
3542  void* data,
3543  EncodedLength length,
3544  SchemaVersion version = Schema::Version)
3545  : SbeMessage(data, length, version)
3546  {
3547  checkVersion<Schema>(version);
3548  checkLength(length, version);
3549  initHeader(TemplateId, blockLength(version), Schema::Id);
3550  reset();
3551  }
3552 
3553  /// Initializes an instance over the given memory block
3554  /// With no variable-length fields initialization
3555  /// It is assumed that the user does such an initialization manually.
3556  SecurityStatusRequest209(
3557  void* data,
3558  EncodedLength length,
3559  NoFieldsInit,
3560  SchemaVersion version = Schema::Version)
3561  : SbeMessage(data, length, version)
3562  {
3563  checkVersion<Schema>(version);
3564  checkLength(length, version);
3565  initHeader(TemplateId, blockLength(version), Schema::Id);
3566  resetVariableFields();
3567  }
3568 
3569  /// Initializes an instance over the given memory block.
3570  SecurityStatusRequest209(
3571  void* data,
3572  EncodedLength length,
3573  NoInit)
3574  : SbeMessage(data, length)
3575  {
3576  checkCompatibility();
3577  }
3578 
3579  /// Initializes an instance over the given SBE message.
3580  explicit
3581  SecurityStatusRequest209(
3582  const SbeMessage& message)
3583  : SbeMessage(message)
3584  {
3585  assert(message.valid());
3586 
3587  checkCompatibility();
3588  }
3589 
3590  /// Initializes an instance over the given memory block.
3591  /// Performs no checks.
3592  SecurityStatusRequest209(
3593  void* data,
3594  EncodedLength length,
3595  NoInit,
3596  NoCheck)
3597  ONIXS_CONFLATEDTCP_NOTHROW
3598  : SbeMessage(data, length, NoCheck())
3599  {
3600  assert(schemaId() == Schema::Id);
3601  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
3602  assert(TemplateId == templateId());
3603  }
3604 
3605  /// Unique identifier of the Request. Must be unique per
3606  /// session so it can be referenced in Request Acknowledgment
3607  /// or Request Reject responses from the exchange.
3608  ONIXS_CONFLATEDTCP_NODISCARD
3609  UInt32 reqId() const
3610  ONIXS_CONFLATEDTCP_NOTHROW
3611  {
3612  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3613 
3614  return ordinary<UInt32>(offset);
3615  }
3616 
3617  /// Unique identifier of the Request. Must be unique per
3618  /// session so it can be referenced in Request Acknowledgment
3619  /// or Request Reject responses from the exchange.
3620  ThisType& setReqId(UInt32 value)
3621  ONIXS_CONFLATEDTCP_NOTHROW
3622  {
3623  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 0;
3624 
3625  setOrdinary(offset, value);
3626  return *this;
3627  }
3628 
3629  /// Subscription Request Type indicates to the type of
3630  /// response expected.
3631  ONIXS_CONFLATEDTCP_NODISCARD
3632  SubscriptionReqType::Enum
3633  subscriptionReqType() const
3634  ONIXS_CONFLATEDTCP_NOTHROW
3635  {
3636  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
3637 
3638  return enumeration<SubscriptionReqType>(offset);
3639  }
3640 
3641  /// Subscription Request Type indicates to the type of
3642  /// response expected.
3643  ThisType&
3644  setSubscriptionReqType(
3645  SubscriptionReqType::Enum value)
3646  ONIXS_CONFLATEDTCP_NOTHROW
3647  {
3648  ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR BlockLength offset = 4;
3649 
3650  setEnumeration<SubscriptionReqType>(offset, value);
3651  return *this;
3652  }
3653 
3654  /// \return instance of SecurityGroups repeating group.
3655  ONIXS_CONFLATEDTCP_NODISCARD
3656  SecurityGroups securityGroups() const
3657  ONIXS_CONFLATEDTCP_NOTHROW
3658  {
3659  return getGroup<SecurityGroups>(
3660  SecurityGroupsAccess(),
3661  *this);
3662  }
3663 
3664  /// \return instance of SecurityGroups repeating group.
3665  ONIXS_CONFLATEDTCP_NODISCARD
3666  SecurityGroups securityGroups()
3667  ONIXS_CONFLATEDTCP_NOTHROW
3668  {
3669  return getGroup<SecurityGroups>(
3670  SecurityGroupsAccess(),
3671  *this);
3672  }
3673 
3674  /// Setup repeating group with the given number of entries.
3675  /// Sets all optional fields of the group entries to null.
3676  /// \return NoSecurityGroups(37022) repeating group.
3677  SecurityGroups
3678  securityGroups(
3679  SecurityGroups::Size length)
3680  {
3681  return constructGroup<SecurityGroups>(
3682  SecurityGroupsAccess(),
3683  length,
3684  *this);
3685  }
3686 
3687  /// Setup repeating group with the given number of entries.
3688  /// \return NoSecurityGroups(37022) repeating group.
3689  SecurityGroups
3690  securityGroups(
3691  SecurityGroups::Size length,
3692  NoFieldsInit)
3693  {
3694  return setupGroup<SecurityGroups>(
3695  SecurityGroupsAccess(),
3696  length,
3697  *this);
3698  }
3699 
3700  /// \return instance of RelatedSym repeating group.
3701  ONIXS_CONFLATEDTCP_NODISCARD
3702  RelatedSym relatedSym() const
3703  ONIXS_CONFLATEDTCP_NOTHROW
3704  {
3705  return getGroup<RelatedSym>(
3706  RelatedSymAccess(),
3707  *this);
3708  }
3709 
3710  /// \return instance of RelatedSym repeating group.
3711  ONIXS_CONFLATEDTCP_NODISCARD
3712  RelatedSym relatedSym()
3713  ONIXS_CONFLATEDTCP_NOTHROW
3714  {
3715  return getGroup<RelatedSym>(
3716  RelatedSymAccess(),
3717  *this);
3718  }
3719 
3720  /// Setup repeating group with the given number of entries.
3721  /// Sets all optional fields of the group entries to null.
3722  /// \return NoRelatedSym(146) repeating group.
3723  RelatedSym relatedSym(RelatedSym::Size length)
3724  {
3725  return constructGroup<RelatedSym>(
3726  RelatedSymAccess(),
3727  length,
3728  *this);
3729  }
3730 
3731  /// Setup repeating group with the given number of entries.
3732  /// \return NoRelatedSym(146) repeating group.
3733  RelatedSym
3734  relatedSym(
3735  RelatedSym::Size length,
3736  NoFieldsInit)
3737  {
3738  return setupGroup<RelatedSym>(
3739  RelatedSymAccess(),
3740  length,
3741  *this);
3742  }
3743 
3744  /// Size of message body in bytes.
3745  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3746  ONIXS_CONFLATEDTCP_CONSTEXPR
3747  static
3748  BlockLength
3749  blockLength(
3750  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
3751  ONIXS_CONFLATEDTCP_NOTHROW
3752  {
3753  return
3754  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3755  5;
3756  }
3757 
3758  /// Minimal variable fields size (when variable-length fields are empty).
3759  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3760  ONIXS_CONFLATEDTCP_NODISCARD
3761  ONIXS_CONFLATEDTCP_CONSTEXPR
3762  static
3763  MessageSize
3764  getMinimalVariableFieldsSize(
3765  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
3766  {
3767  return
3768  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
3769  SecurityGroups::EmptySize + RelatedSym::EmptySize;
3770  }
3771 
3772  /// Maximal message size.
3773  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3774  ONIXS_CONFLATEDTCP_NODISCARD
3775  ONIXS_CONFLATEDTCP_CONSTEXPR
3776  static
3777  UInt64
3778  getMaxMessageSize(
3779  UInt8 maxGroupItems = 255)
3780  ONIXS_CONFLATEDTCP_NOTHROW
3781  {
3782  return
3783  static_cast<UInt64>(MessageHeaderBuilder::Size) +
3784  blockLength(Schema::Version) +
3785  (GroupSize::Size + SecurityGroupsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems)) +
3786  (GroupSize::Size + RelatedSymEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
3787  }
3788 
3789  /// Reset all variable-length fields if any.
3790  ThisType& resetVariableFields()
3791  ONIXS_CONFLATEDTCP_NOTHROW
3792  {
3793  setSecurityGroupsToNull();
3794  setRelatedSymToNull();
3795  return *this;
3796  }
3797 
3798  /// Reset all variable-length and optional fields if any.
3799  ThisType& reset()
3800  ONIXS_CONFLATEDTCP_NOTHROW
3801  {
3802  resetVariableFields();
3803  return *this;
3804  }
3805 
3806  /// \return class name.
3807  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3808  ONIXS_CONFLATEDTCP_NODISCARD
3809  ONIXS_CONFLATEDTCP_CONSTEXPR
3810  static const Char* className()
3811  {
3812  return "SecurityStatusRequest209";
3813  }
3814 
3815  /// FIX message type.
3816  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
3817  ONIXS_CONFLATEDTCP_NODISCARD
3818  ONIXS_CONFLATEDTCP_CONSTEXPR
3819  static StrRef fixType()
3820  ONIXS_CONFLATEDTCP_NOTHROW
3821  {
3822  return constructStrRef("g");
3823  }
3824 
3825  /// \return a human-readable presentation.
3826  ONIXS_CONFLATEDTCP_NODISCARD
3827  std::string toString() const;
3828 
3829  /// \return the end of the message.
3830  ONIXS_CONFLATEDTCP_NODISCARD
3831  const void* tail() const
3832  ONIXS_CONFLATEDTCP_NOTHROW
3833  {
3834  return
3835  relatedSym().tail();
3836  }
3837 
3838  /// \return the size occupied by the message.
3839  ONIXS_CONFLATEDTCP_NODISCARD
3840  EncodedLength calculateBinarySize() const
3841  ONIXS_CONFLATEDTCP_NOTHROW
3842  {
3843  return
3844  SbeMessage::calculateBinarySize(tail());
3845  }
3846 
3847 private:
3848  void checkLength(
3849  EncodedLength length, SchemaVersion version) const
3850  {
3851  const EncodedLength minimalRequiredLength =
3852  blockLength(version) +
3853  MessageHeader::Size +
3854  getMinimalVariableFieldsSize(version);
3855 
3856  checkBinaryLength(
3857  *this, length, minimalRequiredLength);
3858  }
3859 
3860  /// Checks variable fields consistency.
3861  void checkVarLenFields() const
3862  {
3863  groups().
3864  checkTail<SecurityGroups>().
3865  checkTail<RelatedSym>();
3866  }
3867 
3868  void checkCompatibility() const
3869  {
3870  assert(TemplateId == templateId());
3871 
3872  checkSchema<Schema>(schemaId(), version());
3873  checkLength(bufferSize(), version());
3874  checkVarLenFields();
3875  }
3876 
3877  /// Access helper.
3878  struct SecurityGroupsAccess
3879  {
3880  SecurityGroups
3881  operator()(
3882  const SecurityStatusRequest209& obj) const
3883  ONIXS_CONFLATEDTCP_NOTHROW
3884  {
3885  return obj.
3886  groups().
3887  head<SecurityGroups>();
3888  }
3889  };
3890 
3891  /// Reset an instance of the repeating group.
3892  /// All the following data will be invalidated.
3893  void setSecurityGroupsToNull()
3894  ONIXS_CONFLATEDTCP_NOTHROW
3895  {
3896  resetGroup<SecurityGroups>(
3897  SecurityGroupsAccess(),
3898  *this);
3899  }
3900 
3901  /// Access helper.
3902  struct RelatedSymAccess
3903  {
3904  RelatedSym
3905  operator()(
3906  const SecurityStatusRequest209& obj) const
3907  ONIXS_CONFLATEDTCP_NOTHROW
3908  {
3909  return obj.
3910  groups().
3911  tail<SecurityGroups>().
3912  head<RelatedSym>();
3913  }
3914  };
3915 
3916  /// Reset an instance of the repeating group.
3917  /// All the following data will be invalidated.
3918  void setRelatedSymToNull()
3919  ONIXS_CONFLATEDTCP_NOTHROW
3920  {
3921  resetGroup<RelatedSym>(
3922  RelatedSymAccess(),
3923  *this);
3924  }
3925 };
3926 
3927 /// SubscriberHeartbeat.
3928 ONIXS_CONFLATEDTCP_LTWT_STRUCT
3929 SubscriberHeartbeat210
3930 : SbeMessage
3931 {
3932  /// Used template schema.
3933  typedef SchemaTraits Schema;
3934 
3935  /// This type alias.
3936  typedef SubscriberHeartbeat210 ThisType;
3937 
3938  /// Message template ID from SBE schema.
3939  enum { TemplateId = 210 };
3940 
3941  /// Initializes a blank instance.
3942  SubscriberHeartbeat210() ONIXS_CONFLATEDTCP_DEFAULT;
3943 
3944  /// Initializes an instance over the given memory block.
3945  SubscriberHeartbeat210(
3946  void* data,
3947  EncodedLength length,
3948  SchemaVersion version = Schema::Version)
3949  : SbeMessage(data, length, version)
3950  {
3951  checkVersion<Schema>(version);
3952  checkLength(length, version);
3953  initHeader(TemplateId, blockLength(version), Schema::Id);
3954  reset();
3955  }
3956 
3957  /// Initializes an instance over the given memory block
3958  /// With no variable-length fields initialization
3959  /// It is assumed that the user does such an initialization manually.
3960  SubscriberHeartbeat210(
3961  void* data,
3962  EncodedLength length,
3963  NoFieldsInit,
3964  SchemaVersion version = Schema::Version)
3965  : SbeMessage(data, length, version)
3966  {
3967  checkVersion<Schema>(version);
3968  checkLength(length, version);
3969  initHeader(TemplateId, blockLength(version), Schema::Id);
3970  resetVariableFields();
3971  }
3972 
3973  /// Initializes an instance over the given memory block.
3974  SubscriberHeartbeat210(
3975  void* data,
3976  EncodedLength length,
3977  NoInit)
3978  : SbeMessage(data, length)
3979  {
3980  checkCompatibility();
3981  }
3982 
3983  /// Initializes an instance over the given SBE message.
3984  explicit
3985  SubscriberHeartbeat210(
3986  const SbeMessage& message)
3987  : SbeMessage(message)
3988  {
3989  assert(message.valid());
3990 
3991  checkCompatibility();
3992  }
3993 
3994  /// Initializes an instance over the given memory block.
3995  /// Performs no checks.
3996  SubscriberHeartbeat210(
3997  void* data,
3998  EncodedLength length,
3999  NoInit,
4000  NoCheck)
4001  ONIXS_CONFLATEDTCP_NOTHROW
4002  : SbeMessage(data, length, NoCheck())
4003  {
4004  assert(schemaId() == Schema::Id);
4005  assert(static_cast<Int16>(version()) >= Schema::MinimalVersion);
4006  assert(TemplateId == templateId());
4007  }
4008 
4009  /// Size of message body in bytes.
4010  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
4011  ONIXS_CONFLATEDTCP_CONSTEXPR
4012  static
4013  BlockLength
4014  blockLength(
4015  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
4016  ONIXS_CONFLATEDTCP_NOTHROW
4017  {
4018  return
4019  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
4020  0;
4021  }
4022 
4023  /// Minimal variable fields size (when variable-length fields are empty).
4024  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
4025  ONIXS_CONFLATEDTCP_NODISCARD
4026  ONIXS_CONFLATEDTCP_CONSTEXPR
4027  static
4028  MessageSize
4029  getMinimalVariableFieldsSize(
4030  ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
4031  {
4032  return
4033  ONIXS_CONFLATEDTCP_ASSERT(static_cast<Int16>(version) >= Schema::MinimalVersion),
4034  0;
4035  }
4036 
4037  /// Maximal message size.
4038  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
4039  ONIXS_CONFLATEDTCP_NODISCARD
4040  ONIXS_CONFLATEDTCP_CONSTEXPR
4041  static UInt64 getMaxMessageSize(UInt8)
4042  ONIXS_CONFLATEDTCP_NOTHROW
4043  {
4044  return
4045  static_cast<UInt64>(MessageHeaderBuilder::Size) +
4046  blockLength(Schema::Version);
4047  }
4048 
4049  /// Reset all variable-length fields if any.
4050  ThisType& resetVariableFields()
4051  ONIXS_CONFLATEDTCP_NOTHROW
4052  {
4053  return *this;
4054  }
4055 
4056  /// Reset all variable-length and optional fields if any.
4057  ThisType& reset()
4058  ONIXS_CONFLATEDTCP_NOTHROW
4059  {
4060  resetVariableFields();
4061  return *this;
4062  }
4063 
4064  /// \return class name.
4065  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
4066  ONIXS_CONFLATEDTCP_NODISCARD
4067  ONIXS_CONFLATEDTCP_CONSTEXPR
4068  static const Char* className()
4069  {
4070  return "SubscriberHeartbeat210";
4071  }
4072 
4073  /// FIX message type.
4074  ONIXS_CONFLATEDTCP_LTWT_EXPORTED
4075  ONIXS_CONFLATEDTCP_NODISCARD
4076  ONIXS_CONFLATEDTCP_CONSTEXPR
4077  static StrRef fixType()
4078  ONIXS_CONFLATEDTCP_NOTHROW
4079  {
4080  return constructStrRef("0");
4081  }
4082 
4083  /// \return a human-readable presentation.
4084  ONIXS_CONFLATEDTCP_NODISCARD
4085  std::string toString() const;
4086 
4087  /// \return the end of the message.
4088  ONIXS_CONFLATEDTCP_NODISCARD
4089  const void* tail() const
4090  ONIXS_CONFLATEDTCP_NOTHROW
4091  {
4092  return
4093  toOpaquePtr(
4094  advanceByBytes(
4095  binary(),
4096  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
4097  MessageHeader::Size));
4098  }
4099 
4100  /// \return the size occupied by the message.
4101  ONIXS_CONFLATEDTCP_NODISCARD
4102  EncodedLength calculateBinarySize() const
4103  ONIXS_CONFLATEDTCP_NOTHROW
4104  {
4105  return
4106  SbeMessage::calculateBinarySize(tail());
4107  }
4108 
4109 private:
4110  void checkLength(
4111  EncodedLength length, SchemaVersion version) const
4112  {
4113  const EncodedLength minimalRequiredLength =
4114  blockLength(version) +
4115  MessageHeader::Size +
4116  getMinimalVariableFieldsSize(version);
4117 
4118  checkBinaryLength(
4119  *this, length, minimalRequiredLength);
4120  }
4121 
4122  void checkCompatibility() const
4123  {
4124  assert(TemplateId == templateId());
4125 
4126  checkSchema<Schema>(schemaId(), version());
4127  checkLength(bufferSize(), version());
4128  }
4129 };
4130 
4131 
4132 ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_END
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::errorCodes
ErrorCodes::Enum errorCodes() const noexcept
Error code for reject reason.
Definition: Messages.h:528
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::setUuId
ThisType & setUuId(UInt64 value) noexcept
Matches Negotiate.UUID.
Definition: Messages.h:761
OnixS::CME::ConflatedTCP::Messaging::SbeGroup::Size
Entries::Size Size
Number of entries in the group.
Definition: SbeMessage.h:643
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::hmacVersion
static constexpr StrRef hmacVersion() noexcept
Constant value representing CME HMAC version.
Definition: Messages.h:118
OnixS::CME::ConflatedTCP::Messaging::SbeGroup
SBE-encoded repeating group.
Definition: SbeMessage.h:618
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::setReqId
ThisType & setReqId(UInt32 value) noexcept
Unique identifier for Market Data Request.
Definition: Messages.h:2121
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::reqId
bool reqId(UInt32 &value) const noexcept
Unique identifier for Market Data Request.
Definition: Messages.h:2528
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:2211
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::ThisType
SubscriberHeartbeat210 ThisType
This type alias.
Definition: Messages.h:3936
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroupsEntry::setSecurityGroup
ThisType & setSecurityGroup(StrRef value) noexcept
Security Group.
Definition: Messages.h:1906
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::relatedSym
RelatedSym relatedSym(RelatedSym::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:3131
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::requestTimestamp
Timestamp requestTimestamp() const noexcept
Matches Negotiate.RequestTimestamp.
Definition: Messages.h:508
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:301
ONIXS_CONFLATEDTCP_LTWT_EXPORTED
#define ONIXS_CONFLATEDTCP_LTWT_EXPORTED
Definition: ABI.h:92
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSymEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:2923
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::setReqId
ThisType & setReqId(UInt32 value) noexcept
Unique identifier of the Request.
Definition: Messages.h:3017
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry::setSecurityGroup
ThisType & setSecurityGroup(StrRef value) noexcept
Security Group.
Definition: Messages.h:1306
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroupsEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:1862
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::tail
const void * tail() const noexcept
Definition: Messages.h:340
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:3415
ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_END
#define ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_END
Definition: ABI.h:144
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::reqIdStatus
RequestIDStatus::Enum reqIdStatus() const noexcept
Status of the request acknowledgement.
Definition: Messages.h:2155
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:3075
OnixS::CME::ConflatedTCP::Messaging::Terminate203::setRequestTimestamp
ThisType & setRequestTimestamp(Timestamp value) noexcept
Matches last received Negotiate.RequestTimestamp.
Definition: Messages.h:1080
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::SubscriberHeartbeat210
SubscriberHeartbeat210(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:3974
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::NegotiationReject201
NegotiationReject201(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:440
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::subscriptionReqType
SubscriptionReqType::Enum subscriptionReqType() const noexcept
Subscription Request Type indicates to the type of response expected.
Definition: Messages.h:1540
OnixS::CME::ConflatedTCP::Messaging::Terminate203::Terminate203
Terminate203(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:978
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:3690
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RequestAck206
RequestAck206(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:2097
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::setReqRejReason
ThisType & setReqRejReason(ReqRejReason::Enum value) noexcept
Market Data Request Reject reason code.
Definition: Messages.h:2566
ONIXS_CONFLATEDTCP_NOTHROW
#define ONIXS_CONFLATEDTCP_NOTHROW
Definition: Compiler.h:189
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::relatedSym
RelatedSym relatedSym(RelatedSym::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:1641
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::className
static constexpr const Char * className()
Definition: Messages.h:319
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSymEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:2031
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:587
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityStatusRequest209
SecurityStatusRequest209(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:3570
OnixS::CME::ConflatedTCP::Messaging::Terminate203::setUuId
ThisType & setUuId(UInt64 value) noexcept
Matches Negotiate.UUID.
Definition: Messages.h:1060
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3196
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityStatusRequest209
SecurityStatusRequest209(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:3581
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSymEntry::RelatedSymEntry
RelatedSymEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1369
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:2340
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:594
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1280
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:4029
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::calculateBinarySize
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:639
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::setReqId
ThisType & setReqId(UInt32 value) noexcept
Unique identifier for Market Data Request.
Definition: Messages.h:2537
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroups
SbeGroup< SecurityGroupsEntry, GroupSize, MessageSize > SecurityGroups
Repeating group containing SecurityGroupsEntry entries.
Definition: Messages.h:3437
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::relatedSym
RelatedSym relatedSym(RelatedSym::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:1630
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3187
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:853
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry::setSecurityGroup
ThisType & setSecurityGroup(StrRef value) noexcept
Security Group.
Definition: Messages.h:3399
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::relatedSym
RelatedSym relatedSym(RelatedSym::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:2244
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::Schema
SchemaTraits Schema
Used template schema.
Definition: Messages.h:1840
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::subscriptionReqType
SubscriptionReqType::Enum subscriptionReqType() const noexcept
Subscription Request Type indicates to the type of response expected.
Definition: Messages.h:3030
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8 maxGroupItems=255) noexcept
Maximal message size.
Definition: Messages.h:1685
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:4041
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::reqRejReason
ReqRejReason::Enum reqRejReason() const noexcept
Market Data Request Reject reason code.
Definition: Messages.h:2557
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::NegotiationReject201
NegotiationReject201(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:429
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:2812
OnixS::CME::ConflatedTCP::Messaging::Terminate203::Terminate203
Terminate203(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:1014
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2602
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::NegotiationResponse202
NegotiationResponse202(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:737
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSymEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1985
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::subscriptionReqType
SubscriptionReqType::Enum subscriptionReqType() const noexcept
Subscription ReqType.
Definition: Messages.h:2133
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1706
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSym
SbeGroup< RelatedSymEntry, GroupSize, MessageSize > RelatedSym
Repeating group containing RelatedSymEntry entries.
Definition: Messages.h:2040
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:3161
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:2629
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::ThisType
SecurityStatusRequest209 ThisType
This type alias.
Definition: Messages.h:3333
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8 maxGroupItems=255) noexcept
Maximal message size.
Definition: Messages.h:3175
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::ThisType
NegotiationReject201 ThisType
This type alias.
Definition: Messages.h:391
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::RequestReject207
RequestReject207(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:2502
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSymEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:1362
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:308
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::calculateBinarySize
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:2692
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::reason
StrRef reason() const noexcept
Reject reason details.
Definition: Messages.h:466
ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR
#define ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR
Definition: Compiler.h:191
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::Negotiate200
Negotiate200(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:90
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::NegotiationResponse202
NegotiationResponse202(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:701
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroupsEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:1922
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::Schema
SchemaTraits Schema
Used template schema.
Definition: Messages.h:2450
OnixS::CME::ConflatedTCP::Messaging::Terminate203::errorCodes
ErrorCodes::Enum errorCodes() const noexcept
Error code for reject reason.
Definition: Messages.h:1091
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSymEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1380
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::setSecretKeySecureIdExpiration
ThisType & setSecretKeySecureIdExpiration(UInt16NULL value) noexcept
This indicates in how many days the HMAC secret key will expire.
Definition: Messages.h:803
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroupsEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1887
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::className
static constexpr const Char * className()
Definition: Messages.h:2658
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::setFirm
ThisType & setFirm(StrRef value) noexcept
Firm ID.
Definition: Messages.h:250
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSymEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:1960
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::RelatedSymEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3480
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::setUuId
ThisType & setUuId(UInt64 value) noexcept
Matches Negotiate.UUID.
Definition: Messages.h:497
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::RequestReject207
RequestReject207(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:2513
OnixS::CME::ConflatedTCP::Messaging::SbeMessage::EncodedLength
MessageSize EncodedLength
Length of the message binary data.
Definition: SbeMessage.h:1100
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroupsEntry::SecurityGroupsEntry
SecurityGroupsEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1869
OnixS::CME::ConflatedTCP::Messaging::Terminate203::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1150
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::setText
ThisType & setText(StrRef value) noexcept
Reject reason details.
Definition: Messages.h:2587
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSymEntry::setSecurityId
ThisType & setSecurityId(Int32 value) noexcept
Security ID.
Definition: Messages.h:1405
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RequestAck206
RequestAck206(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:2086
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8 maxGroupItems=255) noexcept
Maximal message size.
Definition: Messages.h:3778
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSymEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1387
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:2617
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::NegotiationReject201
NegotiationReject201(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:400
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry::SecurityGroupsEntry
SecurityGroupsEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3362
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::setAccessKeyId
ThisType & setAccessKeyId(StrRef value) noexcept
Contains the AccessKeyID assigned to this session on this port.
Definition: Messages.h:160
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:1726
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:826
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroupsEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1880
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::MarketDataRequest205
MarketDataRequest205(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:1499
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:841
OnixS::CME::ConflatedTCP::Messaging::Terminate203::setReason
ThisType & setReason(StrRef value) noexcept
Reject reason details.
Definition: Messages.h:1039
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityListRequest208
SecurityListRequest208(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:2989
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::setUuId
ThisType & setUuId(UInt64 value) noexcept
Session Identifier defined as type long uInt64, recommended to use timestamp as number of microsecond...
Definition: Messages.h:185
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::NegotiationReject201
NegotiationReject201(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:415
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RequestAck206
RequestAck206(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:2075
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::SubscriberHeartbeat210
SubscriberHeartbeat210(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:3960
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSymEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:1433
OnixS::CME::ConflatedTCP::Messaging::SchemaTraits
Attributes of SBE message schema.
Definition: SchemaTraits.h:37
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::Negotiate200
Negotiate200(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:101
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::setHmacSignature
ThisType & setHmacSignature(StrRef value) noexcept
Contains the HMAC signature.
Definition: Messages.h:136
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::setSubscriptionReqType
ThisType & setSubscriptionReqType(SubscriptionReqType::Enum value) noexcept
Subscription Request Type indicates to the type of response expected.
Definition: Messages.h:3041
OnixS::CME::ConflatedTCP::Messaging::UInt16NULL
UInt16 UInt16NULL
Unsigned Int16 with NULL.
Definition: Fields.h:34
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroupsEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:1935
OnixS::CME::ConflatedTCP::Messaging::Terminate203::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:1129
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::uuId
UInt64 uuId() const noexcept
Matches Negotiate.UUID.
Definition: Messages.h:752
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:2667
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::calculateBinarySize
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:1747
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:3146
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry
Number of SecurityGroups specified in subscription request.
Definition: Messages.h:1250
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::reqId
UInt32 reqId() const noexcept
Unique identifier of the Request.
Definition: Messages.h:3006
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::uuId
UInt64 uuId() const noexcept
Matches Negotiate.UUID.
Definition: Messages.h:488
OnixS::CME::ConflatedTCP::Messaging::Terminate203::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:1114
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::ThisType
SecurityListRequest208 ThisType
This type alias.
Definition: Messages.h:2730
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2270
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:3355
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::session
StrRef session() const noexcept
Session ID.
Definition: Messages.h:218
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:1671
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::accessKeyId
StrRef accessKeyId() const noexcept
Contains the AccessKeyID assigned to this session on this port.
Definition: Messages.h:149
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:1335
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::Negotiate200
Negotiate200(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:79
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:2825
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSym
SbeGroup< RelatedSymEntry, GroupSize, MessageSize > RelatedSym
Repeating group containing RelatedSymEntry entries.
Definition: Messages.h:2932
OnixS::CME::ConflatedTCP::Messaging::StrRef
std::basic_string_view< Char > StrRef
Definition: StrRef.h:46
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::firm
StrRef firm() const noexcept
Firm ID.
Definition: Messages.h:240
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::relatedSym
RelatedSym relatedSym(RelatedSym::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:3723
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::setSubscriptionReqType
ThisType & setSubscriptionReqType(SubscriptionReqType::Enum value) noexcept
Subscription Request Type indicates to the type of response expected.
Definition: Messages.h:3644
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:1322
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSym
SbeGroup< RelatedSymEntry, GroupSize, MessageSize > RelatedSym
Repeating group containing RelatedSymEntry entries.
Definition: Messages.h:1442
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::secretKeySecureIdExpiration
bool secretKeySecureIdExpiration(UInt16NULL &value) const noexcept
This indicates in how many days the HMAC secret key will expire.
Definition: Messages.h:793
OnixS::CME::ConflatedTCP::Messaging::Terminate203::Terminate203
Terminate203(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:992
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::Negotiate200
Negotiate200(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:50
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:614
ONIXS_CONFLATEDTCP_CONSTEXPR
#define ONIXS_CONFLATEDTCP_CONSTEXPR
Definition: Compiler.h:192
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:2770
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:3087
OnixS::CME::ConflatedTCP::Messaging::Terminate203::Schema
SchemaTraits Schema
Used template schema.
Definition: Messages.h:951
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:2777
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:2311
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:4057
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:1656
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry::SecurityGroupsEntry
SecurityGroupsEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1269
OnixS::CME::ConflatedTCP::Messaging::SbeGroupEntry< GroupSize::BlockLength >::BlockLength
GroupSize::BlockLength BlockLength
Type to present the length of binary data of the repeating group entry.
Definition: SbeMessage.h:288
ONIXS_CONFLATEDTCP_NODISCARD
#define ONIXS_CONFLATEDTCP_NODISCARD
Definition: Compiler.h:198
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSymEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1978
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:2320
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::RelatedSymEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:3526
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3380
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::calculateBinarySize
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:2361
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::requestTimestamp
Timestamp requestTimestamp() const noexcept
Time of request, recommended to use timestamp as number of nanoseconds since Unix epoch...
Definition: Messages.h:197
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::setSubscriptionReqType
ThisType & setSubscriptionReqType(SubscriptionReqType::Enum value) noexcept
Subscription ReqType.
Definition: Messages.h:2143
OnixS::CME::ConflatedTCP::Messaging::constructStrRef
constexpr StrRef constructStrRef(const char(&value)[Size]) noexcept
Definition: StrRef.h:415
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::setRequestTimestamp
ThisType & setRequestTimestamp(Timestamp value) noexcept
Time of request, recommended to use timestamp as number of nanoseconds since Unix epoch...
Definition: Messages.h:207
OnixS::CME::ConflatedTCP::Messaging::Timestamp
The time point without the time-zone information.
Definition: Time.h:467
OnixS::CME::ConflatedTCP::Messaging::SbeGroupEntry
Operations over a repeating group instance.
Definition: SbeMessage.h:284
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:1262
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityListRequest208
SecurityListRequest208(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:2953
OnixS::CME::ConflatedTCP::Messaging::Terminate203::setErrorCodes
ThisType & setErrorCodes(ErrorCodes::Enum value) noexcept
Error code for reject reason.
Definition: Messages.h:1100
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::RelatedSym
SbeGroup< RelatedSymEntry, GroupSize, MessageSize > RelatedSym
Repeating group containing RelatedSymEntry entries.
Definition: Messages.h:3535
OnixS::CME::ConflatedTCP::Messaging::NullUInt16NULL
IntegralConstant< UInt16, 65535 > NullUInt16NULL
Null value for an optional UInt16NULL field.
Definition: Fields.h:156
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:1597
OnixS::CME::ConflatedTCP::Messaging::SbeMessage::BlockLength
MessageSize BlockLength
Length of the message body representing a block of fixed-length fields.
Definition: SbeMessage.h:1103
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSymEntry::RelatedSymEntry
RelatedSymEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:1967
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::SubscriberHeartbeat210
SubscriberHeartbeat210(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:3985
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::setReason
ThisType & setReason(StrRef value) noexcept
Reject reason details.
Definition: Messages.h:476
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:4050
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:869
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroups
SbeGroup< SecurityGroupsEntry, GroupSize, MessageSize > SecurityGroups
Repeating group containing SecurityGroupsEntry entries.
Definition: Messages.h:1344
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::setReqId
ThisType & setReqId(UInt32 value) noexcept
Unique identifier of the Request.
Definition: Messages.h:3620
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::ThisType
RequestAck206 ThisType
This type alias.
Definition: Messages.h:1843
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:2638
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:2645
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityListRequest208
SecurityListRequest208(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:2967
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::RelatedSymEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3473
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:3749
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry::className
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:3428
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroups
SbeGroup< SecurityGroupsEntry, GroupSize, MessageSize > SecurityGroups
Repeating group containing SecurityGroupsEntry entries.
Definition: Messages.h:2834
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8 maxGroupItems=255) noexcept
Maximal message size.
Definition: Messages.h:2299
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:2199
OnixS::CME::ConflatedTCP::Messaging::Terminate203::className
static constexpr const Char * className()
Definition: Messages.h:1168
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::text
StrRef text() const noexcept
Reject reason details.
Definition: Messages.h:2577
OnixS::CME::ConflatedTCP::Messaging::GroupSize::BlockLength
UInt16 BlockLength
Type alias for the BlockLength.
Definition: Composites.h:41
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::ThisType
Negotiate200 ThisType
This type alias.
Definition: Messages.h:41
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSymEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:2910
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::reqId
UInt32 reqId() const noexcept
Unique identifier for Market Data Request.
Definition: Messages.h:2112
OnixS::CME::ConflatedTCP::Messaging::SchemaVersion
MessageHeader::Version SchemaVersion
SBE-encoded data version type.
Definition: SchemaTraits.h:30
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::NegotiationResponse202
NegotiationResponse202(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:726
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::relatedSym
RelatedSym relatedSym(RelatedSym::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:2255
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSymEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:2852
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSymEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:2870
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSymEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:2877
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityListRequest208
SecurityListRequest208(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:2978
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::Negotiate200
Negotiate200(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:65
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1697
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry::setSecurityGroup
ThisType & setSecurityGroup(StrRef value) noexcept
Security Group.
Definition: Messages.h:2796
OnixS::CME::ConflatedTCP::Messaging::MessageSize
UInt16 MessageSize
Message length type.
Definition: Aliases.h:29
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::requestTimestamp
Timestamp requestTimestamp() const noexcept
Matches Negotiate.RequestTimestamp.
Definition: Messages.h:772
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::RequestReject207
RequestReject207(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:2462
ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_BEGIN
#define ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_BEGIN
Definition: ABI.h:140
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::setReqId
ThisType & setReqId(UInt32 value) noexcept
Unique identifier for Market Data Request.
Definition: Messages.h:1527
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSymEntry::setSecurityId
ThisType & setSecurityId(Int32 value) noexcept
Security ID.
Definition: Messages.h:2895
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::SubscriberHeartbeat210
SubscriberHeartbeat210(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:3945
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::RequestReject207
RequestReject207(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:2491
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::relatedSym
RelatedSym relatedSym(RelatedSym::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:3734
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:551
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:3764
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::RequestReject207
RequestReject207(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:2477
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:862
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:4077
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:3819
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::setRequestTimestamp
ThisType & setRequestTimestamp(Timestamp value) noexcept
Matches Negotiate.RequestTimestamp.
Definition: Messages.h:781
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:578
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::relatedSym
RelatedSym relatedSym(RelatedSym::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:3120
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::subscriptionReqType
SubscriptionReqType::Enum subscriptionReqType() const noexcept
Subscription Request Type indicates to the type of response expected.
Definition: Messages.h:3633
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::Schema
SchemaTraits Schema
Used template schema.
Definition: Messages.h:388
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::MarketDataRequest205
MarketDataRequest205(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:1463
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::setErrorCodes
ThisType & setErrorCodes(ErrorCodes::Enum value) noexcept
Error code for reject reason.
Definition: Messages.h:537
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::SecurityGroups
SbeGroup< SecurityGroupsEntry, GroupSize, MessageSize > SecurityGroups
Repeating group containing SecurityGroupsEntry entries.
Definition: Messages.h:1944
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:3678
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::RelatedSymEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:3455
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RequestAck206
RequestAck206(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:2061
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:3216
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::SubscriberHeartbeat210
SubscriberHeartbeat210(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:3996
OnixS::CME::ConflatedTCP::Messaging::Terminate203::Terminate203
Terminate203(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:963
OnixS::CME::ConflatedTCP::Messaging::NullUInt32
IntegralConstant< UInt32, 4294967295 > NullUInt32
Null value for an optional UInt32 field.
Definition: Fields.h:162
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSymEntry::setSecurityId
ThisType & setSecurityId(Int32 value) noexcept
Security ID.
Definition: Messages.h:2003
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:328
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3373
OnixS::CME::ConflatedTCP::Messaging::Terminate203::Terminate203
Terminate203(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:1003
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::NegotiationResponse202
NegotiationResponse202(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:715
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::ThisType
NegotiationResponse202 ThisType
This type alias.
Definition: Messages.h:677
OnixS::CME::ConflatedTCP::Messaging::SubscriberHeartbeat210::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:4014
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:891
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::RelatedSymEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:2018
OnixS::CME::ConflatedTCP::Messaging::Terminate203::calculateBinarySize
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:1202
OnixS::CME::ConflatedTCP::Messaging::Terminate203::requestTimestamp
Timestamp requestTimestamp() const noexcept
Matches last received Negotiate.RequestTimestamp.
Definition: Messages.h:1071
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::setRequestTimestamp
ThisType & setRequestTimestamp(Timestamp value) noexcept
Matches Negotiate.RequestTimestamp.
Definition: Messages.h:517
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry
Number of SecurityGroups specified in subscription request.
Definition: Messages.h:2740
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry::SecurityGroupsEntry
SecurityGroupsEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2759
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::SecurityGroupsEntry::Base
SbeGroupEntry< GroupSize::BlockLength > Base
Base class type.
Definition: Messages.h:2752
OnixS::CME::ConflatedTCP::Messaging::Terminate203::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:1141
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityStatusRequest209
SecurityStatusRequest209(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:3592
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::className
static constexpr const Char * className()
Definition: Messages.h:2331
OnixS::CME::ConflatedTCP::Messaging::Terminate203::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:1177
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::setSession
ThisType & setSession(StrRef value) noexcept
Session ID.
Definition: Messages.h:228
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::securityGroups
SecurityGroups securityGroups() const noexcept
Definition: Messages.h:2177
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::reqId
UInt32 reqId() const noexcept
Unique identifier for Market Data Request.
Definition: Messages.h:1516
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:280
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::getMaxMessageSize
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:292
ONIXS_CONFLATEDTCP_LTWT_STRUCT
#define ONIXS_CONFLATEDTCP_LTWT_STRUCT
Definition: ABI.h:88
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityStatusRequest209
SecurityStatusRequest209(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:3556
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::uuId
UInt64 uuId() const noexcept
Session Identifier defined as type long uInt64, recommended to use timestamp as number of microsecond...
Definition: Messages.h:174
OnixS::CME::ConflatedTCP::Messaging::RequestReject207::ThisType
RequestReject207 ThisType
This type alias.
Definition: Messages.h:2453
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::setSubscriptionReqType
ThisType & setSubscriptionReqType(SubscriptionReqType::Enum value) noexcept
Subscription Request Type indicates to the type of response expected.
Definition: Messages.h:1551
OnixS::CME::ConflatedTCP::Messaging::Terminate203::reason
StrRef reason() const noexcept
Reject reason details.
Definition: Messages.h:1029
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::SecurityGroupsEntry
Number of SecurityGroups specified in subscription request.
Definition: Messages.h:3343
OnixS::CME::ConflatedTCP::Messaging::Terminate203::ThisType
Terminate203 ThisType
This type alias.
Definition: Messages.h:954
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::RelatedSymEntry::RelatedSymEntry
RelatedSymEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:3462
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::MarketDataRequest205
MarketDataRequest205(const SbeMessage &message)
Initializes an instance over the given SBE message.
Definition: Messages.h:1488
OnixS::CME::ConflatedTCP::Messaging::Terminate203::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1157
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::Schema
SchemaTraits Schema
Used template schema.
Definition: Messages.h:38
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3799
OnixS::CME::ConflatedTCP::Messaging::SecurityListRequest208::RelatedSymEntry::RelatedSymEntry
RelatedSymEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:2859
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::ThisType
MarketDataRequest205 ThisType
This type alias.
Definition: Messages.h:1240
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::calculateBinarySize
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:353
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::securityGroups
SecurityGroups securityGroups(SecurityGroups::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:1585
OnixS::CME::ConflatedTCP::Messaging::Char
char Char
Character type alias.
Definition: String.h:30
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::NegotiationReject201
NegotiationReject201(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Initializes an instance over the given memory block.
Definition: Messages.h:451
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::reqId
UInt32 reqId() const noexcept
Unique identifier of the Request.
Definition: Messages.h:3609
OnixS::CME::ConflatedTCP::Messaging::NegotiationResponse202::NegotiationResponse202
NegotiationResponse202(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:686
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::resetVariableFields
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3790
OnixS::CME::ConflatedTCP::Messaging::SecurityStatusRequest209::RelatedSymEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:3513
OnixS::CME::ConflatedTCP::Messaging::Terminate203::uuId
UInt64 uuId() const noexcept
Matches Negotiate.UUID.
Definition: Messages.h:1051
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::hmacSignature
StrRef hmacSignature() const noexcept
Contains the HMAC signature.
Definition: Messages.h:126
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::RelatedSymEntry::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Definition: Messages.h:1420
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:2285
OnixS::CME::ConflatedTCP::Messaging::RequestAck206::setReqIdStatus
ThisType & setReqIdStatus(RequestIDStatus::Enum value) noexcept
Status of the request acknowledgement.
Definition: Messages.h:2165
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::MarketDataRequest205
MarketDataRequest205(void *data, EncodedLength length, NoInit)
Initializes an instance over the given memory block.
Definition: Messages.h:1477
OnixS::CME::ConflatedTCP::Messaging::Negotiate200::blockLength
static constexpr BlockLength blockLength(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:265
OnixS::CME::ConflatedTCP::Messaging::NegotiationReject201::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(ONIXS_CONFLATEDTCP_UNUSED SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:566
OnixS::CME::ConflatedTCP::Messaging::MarketDataRequest205::SecurityGroupsEntry::reset
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1287