OnixS CME Drop Copy Handler C++ library  5.6.0
API documentation
Messaging.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 protected by copyright law
4 // and international copyright treaties.
5 //
6 // Access to and use of the software is governed by the terms of the applicable OnixS Software
7 // Services Agreement (the Agreement) and Customer end user license agreements granting
8 // a non-assignable, non-transferable and non-exclusive license to use the software
9 // for it's own data processing purposes under the terms defined in the Agreement.
10 //
11 // Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
12 // of this source code or associated reference material to any other location for further reproduction
13 // or redistribution, and any amendments to this copyright notice, are expressly prohibited.
14 //
15 // Any reproduction or redistribution for sale or hiring of the Software not in accordance with
16 // the terms of the Agreement is a violation of copyright law.
17 //
18 
19 #pragma once
20 
21 #include "OnixS/CME/DropCopy/Export.h"
26 
27 namespace OnixS { namespace CME { namespace DropCopy {
28 
29 class Message;
30 class Group;
31 class MessageOperator;
32 
33 /// Reference to a read-only FIX field value.
34 ///
35 /// Reference may refers to a valid field value or
36 /// to nothing. 'operator bool()' is exposed to check
37 /// whether instance refers to existent field value.
38 class ONIXS_CME_DROP_COPY_EXPORT FieldValueRef
39 {
40 public:
41  /// Uninitialized value.
42  FieldValueRef();
43 
44  /// Shallow copy from another one.
46 
47  /// Indicated whether the instance
48  /// refers to a valid value.
49  operator bool() const;
50 
51  /// Return string presentation
52  /// of the value being referenced.
53  operator std::string() const;
54 
55  /// Compares with another instance for equality.
56  bool operator ==(const FieldValueRef&) const;
57 
58  /// Compares with another instance for inequality.
59  bool operator !=(const FieldValueRef&) const;
60 
61  /// Compares string presentation for
62  /// equality with given text reference.
63  bool operator ==(const StringRef&) const;
64 
65  /// Compares string presentation for
66  /// equality with given text reference.
67  bool operator !=(const StringRef&) const;
68 
69  /// Converts field value into a whole number.
70  ///
71  /// \return false if value referenced by instance
72  /// can't be converted into value of target type.
73  ///
74  /// \note conversion of instance referencing
75  /// to nothing always fails.
76  bool toNumber (Int32&) const;
77 
78  /// Converts field value into a whole number.
79  ///
80  /// \return false if value referenced by instance
81  /// can't be converted into value of target type.
82  ///
83  /// \note conversion of instance referencing
84  /// to nothing always fails.
85  bool toNumber (UInt32&) const;
86 
87  /// Converts field value into a whole number.
88  ///
89  /// \return false if value referenced by instance
90  /// can't be converted into value of target type.
91  ///
92  /// \note conversion of instance referencing
93  /// to nothing always fails.
94  bool toNumber (Int64&) const;
95 
96  /// Converts field value into a whole number.
97  ///
98  /// \return false if value referenced by instance
99  /// can't be converted into value of target type.
100  ///
101  /// \note conversion of instance referencing
102  /// to nothing always fails.
103  bool toNumber (UInt64&) const;
104 
105  /// Converts field value into a whole number.
106  ///
107  /// \return false if value referenced by instance
108  /// can't be converted into value of target type.
109  ///
110  /// \note conversion of instance referencing
111  /// to nothing always fails.
112  bool toNumber (Decimal&) const;
113 
114  /// Converts field value into Timestamp.
115  ///
116  /// \return false if value referenced by instance
117  /// can't be converted into value of target type.
118  ///
119  /// \note conversion of instance referencing
120  /// to nothing always fails.
121  bool toTimestamp(Timestamp&, SinceEpochUnit) const;
122 
123  /// If value represents text, returns reference to it.
124  ///
125  /// \return false if value referenced by instance
126  /// can't be converted into value of target type.
127  /// If value being referenced is not of string type
128  /// (like number or datetime), conversion fails.
129  ///
130  /// \note conversion of instance referencing
131  /// to nothing always fails.
132  bool toStringRef (StringRef&) const;
133 
134  /// If value represent one-char text,
135  /// copies it into given variable.
136  ///
137  /// \return false if value referenced by instance
138  /// can't be converted into value of target type.
139  ///
140  /// \note conversion of instance referencing
141  /// to nothing always fails.
142  bool toChar (char&) const;
143 
144  /// If repeating group is associated with
145  /// field, allows to get instance of it.
146  ///
147  /// \return false if no group is associated with field.
148  bool toGroup (Group&) const;
149 
150  /// Appends copy of referenced value text
151  /// presentation to the std::string.
152  void toString (std::string&) const;
153 
154  /// Return string presentation of field value.
155  std::string toString() const;
156 
157  /// Updates instance to refer to another field value.
158  /// \warning Does NOT perform deep copy of field values.
159  /// Just updates reference to point to value of other field.
160  FieldValueRef& operator =(const FieldValueRef&);
161 
162 private:
163  friend class MessageOperator;
164 
165  const void* impl_;
166  const Message* container_;
167 
168  FieldValueRef(const Message*, const void*);
169 };
170 
171 inline FieldValueRef::operator std::string() const
172 {
173  std::string str;
174  toString (str);
175  return str;
176 }
177 
178 inline std::string FieldValueRef::toString() const
179 {
180  std::string str;
181  toString (str);
182  return str;
183 }
184 
185 // More comparison operators.
186 
187 inline bool operator == (const FieldValueRef& ref, const std::string& str)
188 {
189  return ref == StringRef (str);
190 }
191 
192 inline bool operator != (const FieldValueRef& ref, const std::string& str)
193 {
194  return ref != StringRef (str);
195 }
196 
197 inline bool operator == (const std::string& str, const FieldValueRef& ref)
198 {
199  return ref == StringRef (str);
200 }
201 
202 inline bool operator != (const std::string& str, const FieldValueRef& ref)
203 {
204  return ref != StringRef (str);
205 }
206 
207 // More comparison operators.
208 
209 inline bool operator == (const FieldValueRef& ref, const char* str)
210 {
211  return ref == StringRef (str);
212 }
213 
214 inline bool operator != (const FieldValueRef& ref, const char* str)
215 {
216  return ref != StringRef (str);
217 }
218 
219 inline bool operator == (const char* str, const FieldValueRef& ref)
220 {
221  return ref == StringRef (str);
222 }
223 
224 inline bool operator != (const char* str, const FieldValueRef& ref)
225 {
226  return ref != StringRef (str);
227 }
228 
229 /// Encapsulates primary operations over collection of FIX
230 /// fields like FIX message and repeating group instance are.
231 class ONIXS_CME_DROP_COPY_EXPORT FieldSet
232 {
233 public:
234  /// Indicates whether instance refers to a valid set of fields.
235  ///
236  /// If given instance doesn't refer to a valid fields set,
237  /// none of other members must be used.
238  operator bool() const;
239 
240  /// Provides access to field value using field tag.
241  ///
242  /// \return Reference to a value associated with field
243  /// identified by tag. If there's no value associated with
244  /// a field, returned reference refers to nothing.
245  ///
246  /// \warning Due to performance considerations, doesn't
247  /// check whether instance refers to a valid set of fields.
248  /// Use casting to bool operator to check whether instance
249  /// refers to a valid set of fields.
250  FieldValueRef get (Tag tag) const;
251 
252  /// Returns field value as a char value.
253  ///
254  /// \throw std::exception if field is absent or associated
255  /// value can't be converted to target type.
256  ///
257  /// \warning Due to performance considerations, doesn't
258  /// check whether instance refers to a valid set of fields.
259  /// Use casting to bool operator to check whether instance
260  /// refers to a valid set of fields.
261  char getChar(Tag tag) const;
262 
263  /// Returns field value as an Int32 value.
264  ///
265  /// \throw std::exception if field is absent or associated
266  /// value can't be converted to target type.
267  ///
268  /// \warning Due to performance considerations, doesn't
269  /// check whether instance refers to a valid set of fields.
270  /// Use casting to bool operator to check whether instance
271  /// refers to a valid set of fields.
272  Int32 getInt32 (Tag tag) const;
273 
274  /// Returns field value as an UInt32 value.
275  ///
276  /// \throw std::exception if field is absent or associated
277  /// value can't be converted to target type.
278  ///
279  /// \warning Due to performance considerations, doesn't
280  /// check whether instance refers to a valid set of fields.
281  /// Use casting to bool operator to check whether instance
282  /// refers to a valid set of fields.
283  UInt32 getUInt32 (Tag tag) const;
284 
285  /// Returns field value as an Int64 value.
286  ///
287  /// \throw std::exception if field is absent or associated
288  /// value can't be converted to target type.
289  ///
290  /// \warning Due to performance considerations, doesn't
291  /// check whether instance refers to a valid set of fields.
292  /// Use casting to bool operator to check whether instance
293  /// refers to a valid set of fields.
294  Int64 getInt64 (Tag tag) const;
295 
296  /// Returns field value as an UInt64 value.
297  ///
298  /// \throw std::exception if field is absent or associated
299  /// value can't be converted to target type.
300  ///
301  /// \warning Due to performance considerations, doesn't
302  /// check whether instance refers to a valid set of fields.
303  /// Use casting to bool operator to check whether instance
304  /// refers to a valid set of fields.
305  UInt64 getUInt64 (Tag tag) const;
306 
307  /// Returns the field value as a decimal number.
308  ///
309  /// \throw std::exception if field is absent or associated
310  /// value can't be converted to target type.
311  ///
312  /// \warning Due to performance considerations, doesn't
313  /// check whether instance refers to a valid set of fields.
314  /// Use casting to bool operator to check whether instance
315  /// refers to a valid set of fields.
316  Decimal getDecimal (Tag tag) const;
317 
318  /// Returns reference to a read-only text chain.
319  ///
320  /// \throw std::exception if field is absent or associated
321  /// value can't be converted to target type.
322  ///
323  /// \warning Due to performance considerations, doesn't
324  /// check whether instance refers to a valid set of fields.
325  /// Use casting to bool operator to check whether instance
326  /// refers to a valid set of fields.
327  StringRef getStringRef (Tag tag) const;
328 
329  /// Returns the field value as timestamp of requested format.
330  ///
331  /// \throw std::exception if field is absent or associated
332  /// value can't be converted to target type.
333  ///
334  /// \warning Due to performance considerations, doesn't
335  /// check whether instance refers to a valid set of fields.
336  /// Use casting to bool operator to check whether instance
337  /// refers to a valid set of fields.
338  Timestamp getTimestamp (Tag tag, SinceEpochUnit unit) const;
339 
340  /// Returns reference to a repeating group if underlying
341  /// field defines length of repeating group.
342  ///
343  /// \param tag represent tag number of the field that defines
344  /// number of instances in this repeating group (the NoXXX field).
345  ///
346  /// \throw std::exception if no repeating group is
347  /// associated with given field including field absence.
348  Group getGroup (Tag tag) const;
349 
350  /// Returns reference to a repeating group if underlying
351  /// field defines length of repeating group. If field is absent
352  /// returns instance referencing to nothing. If field is undefined
353  /// for this message throws exception (if strict parameter is true)
354  /// or returns instance referencing to nothing (if strict parameter is false).
355  ///
356  /// \param tag represent tag number of the field that defines
357  /// number of instances in this repeating group (the NoXXX field).
358  /// \param strict set to true (default) if field undefined for this message
359  /// shall throw exception or to false if shall return empty group instance.
360  ///
361  /// \throw std::exception if given field is undefined (and strict parameter
362  /// is true) or doesn't suppose to represent repeating group.
363  Group getOptionalGroup (Tag tag, bool strict = true) const;
364 
365  /// Returns true if the given flag is present
366  /// and it equals to "Y", otherwise false.
367  ///
368  /// \warning Due to performance considerations, doesn't
369  /// check whether instance refers to a valid set of fields.
370  /// Use operator bool() to check whether
371  /// instance is in valid state.
372  bool hasFlag (Tag tag) const;
373 
374  /// Checks the presence of a field
375  /// This method should be used if the actual field value is NOT of interest -
376  /// otherwise field lookup operation will be done twice.
377  bool contain (Tag tag) const;
378 
379 protected:
380  // Underlying implementation.
381  const void* impl_;
382 
383  // Message to which given set belongs to.
385 
386  // Full details initialization.
387  FieldSet (const Message*, const void*);
388 
389  // Clone construction.
390  FieldSet (const FieldSet&);
391 
392  // Destruction available via descendants.
393  ~FieldSet();
394 
395  FieldSet& operator = (const FieldSet&);
396 
397 private:
398  friend class Message;
399  friend class GroupInstance;
400  friend class MessageOperator;
401 };
402 
403 template<typename Enumeration>
404 inline typename Enumeration::Enum getIntEnumFieldValue(const FieldSet& fieldSet, Tag tag)
405 {
406  UInt32 value = 0;
407  FieldValueRef valueRef = fieldSet.get(tag);
408 
409  return (valueRef && valueRef.toNumber(value)) ? static_cast <typename Enumeration::Enum>(value) : Enumeration::Undefined;
410 }
411 
412 template<typename Enumeration>
413 inline typename Enumeration::Enum getCharEnumFieldValue(const FieldSet& fieldSet, Tag tag)
414 {
415  char value = 0;
416  FieldValueRef valueRef = fieldSet.get(tag);
417 
418  return (valueRef && valueRef.toChar(value)) ? static_cast <typename Enumeration::Enum> (value) : Enumeration::Undefined;
419 }
420 
421 inline bool getDate(const FieldSet& fieldSet, Tag tag, Timestamp& date)
422 {
423  UInt64 value;
424 
425  if (fieldSet.get(tag).toNumber(value))
426  {
428  return true;
429  }
430 
431  return false;
432 }
433 
434 /// Single instance of FIX Repeating Group. Provides access
435 /// to the fields of a particular repeating group instance.
436 ///
437 /// Class behaves like a pointer/reference to a set of FIX
438 /// fields. Coping and assignment operations just update reference
439 /// to the field-set being pointed, no deep copying is performed.
440 class ONIXS_CME_DROP_COPY_EXPORT GroupInstance : public FieldSet
441 {
442 public:
443  /// Initializes instance referencing to nothing.
444  GroupInstance();
445 
446  /// Initializes instance as reference to the other one.
447  GroupInstance (const GroupInstance& other);
448 
449  /// Reinitializes instance as reference of other one.
450  GroupInstance& operator = (const GroupInstance&);
451 
452  /// Instance of Message holding
453  /// given repeating group instance.
454  ///
455  /// \warning Due to performance considerations, doesn't
456  /// check whether instance refers to a valid set of fields.
457  /// Use operator bool() to check whether
458  /// instance is in valid state.
459  const Message& message() const;
460 
461 private:
462  friend class MessageOperator;
463 
464  GroupInstance (const Message*, const void*);
465 };
466 
467 inline const Message& GroupInstance::message() const
468 {
469  return *container_;
470 }
471 
472 /// Encapsulates operations over FIX Repeating Group.
473 ///
474 /// Repeating group represents array of repeating group instances,
475 /// So, class exposes corresponding services to manipulate array
476 /// of repeating group instances. Similar to the GroupInstance
477 /// it behaves like a pointer/reference to the underlying data. It's
478 /// a light-weight object which just wraps internal data.
479 ///
480 /// Group remains valid until corresponding field (which defines
481 /// size/length of repeating group) from field-set (message or outer
482 /// repeating group instance) is updated.
483 class ONIXS_CME_DROP_COPY_EXPORT Group
484 {
485 public:
486  /// Initializes instance as referred to nothing.
487  Group();
488 
489  /// Initializes instance as reference to given repeating group.
490  Group (const Group& other);
491 
492  /// Indicated whether group refers to a valid instance.
493  operator bool() const;
494 
495  /// Return number of instances in repeating group.
496  ///
497  /// \warning Due to performance considerations,
498  /// instance is not checked for validness. Member
499  /// must be used only when instance is in valid state.
500  size_t size() const;
501 
502  /// Accesses to repeating group instance.
503  ///
504  /// \throw std::exception if If index exceeds allowed bounds.
505  ///
506  /// \warning Due to performance considerations,
507  /// instance is not checked for validness. Member
508  /// must be used only when instance is in valid state.
509  const GroupInstance at (size_t index) const;
510 
511  /// Accesses to repeating group instance.
512  ///
513  /// Does NOT check index validness.
514  ///
515  /// \warning Due to performance considerations,
516  /// instance is not checked for validness. Member
517  /// must be used only when instance is in valid state.
518  const GroupInstance operator [] (size_t index) const;
519 
520  /// Reinitializes instance as reference to other one.
521  Group& operator = (const Group& other);
522 
523  /// Instance of Message holding
524  /// given repeating group instance.
525  ///
526  /// \warning Due to performance considerations, doesn't
527  /// check whether instance refers to a valid set of fields.
528  /// Use operator bool() to check whether
529  /// instance is in valid state.
530  const Message& message() const;
531 
532 private:
533  friend class MessageOperator;
534 
535  const void* impl_;
536 
537  const Message* container_;
538 
539  Group(const Message*, const void*);
540 };
541 
542 inline const Message& Group::message() const
543 {
544  return *container_;
545 }
546 
547 template<typename Entry>
549 {
550 public:
551  /// Initializes set with no entries.
553  : underlyingGroup_()
554  {
555  }
556 
557  /// Return number of instances in repeating group.
558  size_t size() const
559  {
560  return underlyingGroup_ ? underlyingGroup_.size() : 0;
561  }
562 
563  /// Indicates whether set has an entries.
564  bool empty() const
565  {
566  return 0 == size();
567  }
568 
569  /// Accesses to repeating group instance.
570  ///
571  /// Does NOT check index validness.
572  Entry operator[] (size_t index) const
573  {
574  return Entry(underlyingGroup_[index]);
575  }
576 
577  /// Accesses to repeating group instance.
578  ///
579  /// check index validness.
580  Entry at (size_t index) const
581  {
582  if (index < size())
583  return Entry(underlyingGroup_[index]);
584 
585  throw std::out_of_range("Index");
586  }
587 
588 protected:
589  TypedGroup (const Group& group)
590  : underlyingGroup_(group)
591  {
592  }
593 
595 };
596 
597 
598 /// Contains flags which affect FIX message textual presentation.
599 struct ONIXS_CME_DROP_COPY_EXPORT MessageStringingFlag
600 {
601  /// Flags which affect FIX message textual presentation.
602  enum Enum
603  {
604  /// Only field values are serialized.
605  NoFieldInfo = 0x0,
606 
607  /// Field tag numbers are included during serialization.
608  IncludeFieldTagNumber = 0x1,
609 
610  /// Field names are included during serialization.
611  IncludeFieldName = 0x2
612  };
613 };
614 
615 /// Collection of message stringing flags.
616 typedef unsigned MessageStringingFlags;
617 
618 /// Encapsulates operations over a FIX Message.
619 ///
620 /// Message supports 'unconstructed' state which can be
621 /// treated as pointer in null state. However, in contrast to
622 /// Group and GroupInstance classes it
623 /// does NOT represent light-weight wrapper over internal structures.
624 /// In fact, it holds all the data which is fully copied on assignment
625 /// or copy construction and disposed at instance destruction.
626 ///
627 /// FIX field related operations now available via FieldSet
628 /// class from which Message class is now derived.
629 class ONIXS_CME_DROP_COPY_EXPORT Message : public FieldSet
630 {
631 public:
632  /// Initializes message in 'unconstructed' state.
633  Message();
634 
635  /// Initializes instance as deep copy of other one.
636  ///
637  /// \param other Message to be copied from.
638  Message(const Message& other);
639 
640  /// Disposes all internal data structures.
641  ///
642  /// \warning Once instance is destructed, all instances of
643  /// Group and GroupInstance classes
644  /// obtained from this instance must not be used any more.
645  ~Message();
646 
647  /// Returns the message type (MsgType(35) field value).
648  FieldValueRef type() const;
649 
650  /// Returns the MsgSeqNum field from CME binary packet header.
651  /// Please note: this field is attributed to packet, not message.
652  /// Packet can contain several messages, so they will share same sequence number.
653  SequenceNumber sequenceNumber() const;
654 
655  /// Returns the Sending Time field from CME binary packet header.
656  /// Please note: this field is attributed to packet, not message.
657  /// Packet can contain several messages, so they will share same sending time.
658  Timestamp sendingTime() const;
659 
660  /// Indicates time when packet
661  /// holding given message was received.
662  const Timestamp& receiveTime() const;
663 
664  /// Returns the string representation of the message using
665  /// the given delimiter and additional control flags.
666  ///
667  /// \param delimiter Defines field delimiter to be used.
668  std::string toString(char delimiter = 0x1) const;
669 
670  /// Appends string representation of the message using
671  /// the given delimiter and additional control flags.
672  ///
673  /// \param str String to which presentation is appended.
674  /// \param delimiter Defines field delimiter to be used.
675  void toString(std::string& str, char delimiter = 0x1) const;
676 
677  // Reassigns message as copy of other one.
678  Message& operator=(const Message&);
679 
680 private:
681  friend class MessageOperator;
682 
683  Message(const void* core, const Timestamp& receiveTime);
684 
685 private:
686  const void* core_;
687  Timestamp receiveTime_;
688 };
689 
690 inline std::string Message::toString(char delimiter) const
691 {
692  std::string str;
693  toString (str, delimiter);
694  return str;
695 }
696 
697 /// Simple wrapper for bitmap field
698 class ONIXS_CME_DROP_COPY_EXPORT BitmapField
699 {
700 public:
701 
702  typedef UInt32 BaseType;
703 
704  /// Initializes bitmap field instance with explicit value.
705  explicit BitmapField(BaseType bits = 0)
706  : bits_(bits)
707  {
708  }
709 
710  /// Initializes bitmap field instance from FIX field set.
711  BitmapField(const FieldSet& msg, Tag tag)
712  : bits_(0)
713  {
714  msg.get(tag).toNumber(bits_);
715  }
716 
717 protected:
718 
719  bool state(BaseType bit) const
720  {
721  return (bits_ >> bit) & 1;
722  }
723 
724  bool any() const
725  {
726  return bits_ != 0;
727  }
728 
729  BaseType bits() const
730  {
731  return bits_;
732  }
733 
734 private:
735  BaseType bits_;
736 };
737 
738 }}}
739 
740 namespace std {
741 
742 // Outputs message into standard stream.
743 ONIXS_CME_DROP_COPY_EXPORT std::ostream& operator<<(std::ostream&, const OnixS::CME::DropCopy::Message&);
744 
745 }
TypedGroup()
Initializes set with no entries.
Definition: Messaging.h:552
Provides efficient way of accessing text-based FIX field values.
Definition: String.h:314
BitmapField(const FieldSet &msg, Tag tag)
Initializes bitmap field instance from FIX field set.
Definition: Messaging.h:711
size_t size() const
Return number of instances in repeating group.
Definition: Messaging.h:558
Entry at(size_t index) const
Definition: Messaging.h:580
const Message & message() const
Definition: Messaging.h:467
unsigned int SequenceNumber
Alias for message/packet sequence number.
Definition: Types.h:27
std::string toString() const
Return string presentation of field value.
Definition: Messaging.h:178
const Message & message() const
Definition: Messaging.h:542
long long Int64
Definition: Numeric.h:34
bool operator==(const FieldValueRef &ref, const std::string &str)
Definition: Messaging.h:187
STL namespace.
bool operator!=(const FieldValueRef &ref, const std::string &str)
Definition: Messaging.h:192
Contains flags which affect FIX message textual presentation.
Definition: Messaging.h:599
unsigned long long UInt64
Definition: Numeric.h:35
static Timestamp fromUnixTimestamp(UInt64 sinceEpoch, SinceEpochUnit unit)
bool empty() const
Indicates whether set has an entries.
Definition: Messaging.h:564
Simple wrapper for bitmap field.
Definition: Messaging.h:698
FieldValueRef get(Tag tag) const
Enumeration::Enum getCharEnumFieldValue(const FieldSet &fieldSet, Tag tag)
Definition: Messaging.h:413
Enum
Flags which affect FIX message textual presentation.
Definition: Messaging.h:602
std::string toString(char delimiter=0x1) const
Definition: Messaging.h:690
TypedGroup(const Group &group)
Definition: Messaging.h:589
unsigned int Tag
FIX message field identifying/indexing type.
Definition: Types.h:30
unsigned int UInt32
Definition: Numeric.h:32
bool getDate(const FieldSet &fieldSet, Tag tag, Timestamp &date)
Definition: Messaging.h:421
bool state(BaseType bit) const
Definition: Messaging.h:719
const Message * container_
Definition: Messaging.h:384
unsigned MessageStringingFlags
Collection of message stringing flags.
Definition: Messaging.h:616
BitmapField(BaseType bits=0)
Initializes bitmap field instance with explicit value.
Definition: Messaging.h:705
Represents timestamp without time-zone information.
Definition: Time.h:455
Decimal type for better precision.
Definition: Numeric.h:43
Enumeration::Enum getIntEnumFieldValue(const FieldSet &fieldSet, Tag tag)
Definition: Messaging.h:404