DataDictionary.h
Go to the documentation of this file.
1/* -*- C++ -*- */
2
3/****************************************************************************
4** Copyright (c) 2001-2014
5**
6** This file is part of the QuickFIX FIX Engine
7**
8** This file may be distributed under the terms of the quickfixengine.org
9** license as defined by quickfixengine.org and appearing in the file
10** LICENSE included in the packaging of this file.
11**
12** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
13** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
14**
15** See http://www.quickfixengine.org/LICENSE for licensing information.
16**
17** Contact ask@quickfixengine.org if any conditions of this licensing are
18** not clear to you.
19**
20****************************************************************************/
21
22#ifndef FIX_DATADICTIONARY_H
23#define FIX_DATADICTIONARY_H
24
25#ifdef _MSC_VER
26#pragma warning( disable : 4503 4355 4786 4290 )
27#endif
28
29#include "Fields.h"
30#include "FieldMap.h"
31#include "DOMDocument.h"
32#include "Exceptions.h"
33#include <set>
34#include <map>
35#include <string.h>
36
37namespace FIX
38{
39class FieldMap;
40class Message;
41
50{
51 typedef std::set < int > MsgFields;
52 typedef std::map < std::string, MsgFields > MsgTypeToField;
53 typedef std::set < std::string > MsgTypes;
54 typedef std::set < int > Fields;
55 typedef std::map < int, bool > NonBodyFields;
56 typedef std::vector< int > OrderedFields;
57
59 {
62
65
66 void push_back(int field)
67 {
68 m_orderedFlds.push_back(field);
69 }
70
72 {
73 if (m_msgOrder)
74 return m_msgOrder;
75
76 int * tmp = new int[m_orderedFlds.size() + 1];
77 int * i = tmp;
78
79 OrderedFields::const_iterator iter;
80 for( iter = m_orderedFlds.begin(); iter != m_orderedFlds.end(); *(i++) = *(iter++) ) {}
81 *i = 0;
82
84 delete [] tmp;
85
86 return m_msgOrder;
87 }
88
89 private:
90
93 };
94
95 typedef std::map<std::string, MessageFieldsOrderHolder > MsgTypeToOrderedFields;
96
98 typedef std::map < int, TYPE::Type > FieldTypes;
99 typedef std::set < std::string > Values;
100 typedef std::map < int, Values > FieldToValue;
101 typedef std::map < int, std::string > FieldToName;
102 typedef std::map < std::string, int > NameToField;
103 typedef std::map < std::pair < int, std::string > , std::string > ValueToName;
104 // while FieldToGroup structure seems to be overcomplicated
105 // in reality it yields a lot of performance because:
106 // 1) avoids memory copying;
107 // 2) first lookup is done by comparing integers and not string objects
108 // TODO: use hash_map with good hashing algorithm
109 typedef std::map < std::string, std::pair < int, DataDictionary* > > FieldPresenceMap;
110 typedef std::map < int, FieldPresenceMap > FieldToGroup;
111
112public:
114 DataDictionary( const DataDictionary& copy );
115 DataDictionary(std::istream& stream , bool preserveMsgFldsOrder = false) throw( ConfigError );
116 DataDictionary(const std::string& url , bool preserveMsgFldsOrder = false) throw( ConfigError );
117 virtual ~DataDictionary();
118
119 void readFromURL( const std::string& url ) throw( ConfigError );
120 void readFromDocument( const DOMDocumentPtr &pDoc ) throw( ConfigError );
121 void readFromStream( std::istream& stream ) throw( ConfigError );
122
123 message_order const& getOrderedFields() const;
124 message_order const& getHeaderOrderedFields() const throw( ConfigError );
125 message_order const& getTrailerOrderedFields() const throw( ConfigError );
126 message_order const& getMessageOrderedFields(const std::string & msgType) const throw( ConfigError );
127
128 // storage functions
129 void setVersion( const std::string& beginString )
130 {
131 m_beginString = beginString;
132 m_hasVersion = true;
133 }
134 std::string getVersion() const
135 {
136 return m_beginString.getString();
137 }
138
139 void addField( int field )
140 {
141 m_fields.insert( field );
142 m_orderedFields.push_back( field );
143 }
144
145 void addFieldName( int field, const std::string& name )
146 {
147 if( m_names.insert( std::make_pair(name, field) ).second == false )
148 throw ConfigError( "Field named " + name + " defined multiple times" );
149 m_fieldNames[field] = name;
150 }
151
152 bool getFieldName( int field, std::string& name ) const
153 {
154 FieldToName::const_iterator i = m_fieldNames.find( field );
155 if(i == m_fieldNames.end()) return false;
156 name = i->second;
157 return true;
158 }
159
160 bool getFieldTag( const std::string& name, int& field ) const
161 {
162 NameToField::const_iterator i = m_names.find( name );
163 if(i == m_names.end()) return false;
164 field = i->second;
165 return true;
166 }
167
168 void addValueName( int field, const std::string& value, const std::string& name )
169 {
170 m_valueNames[std::make_pair(field, value)] = name;
171 }
172
173 bool getValueName( int field, const std::string& value, std::string& name ) const
174 {
175 ValueToName::const_iterator i = m_valueNames.find( std::make_pair(field, value) );
176 if(i == m_valueNames.end()) return false;
177 name = i->second;
178 return true;
179 }
180
181 bool isField( int field ) const
182 {
183 return m_fields.find( field ) != m_fields.end();
184 }
185
186 void addMsgType( const std::string& msgType )
187 {
188 m_messages.insert( msgType );
189 }
190
191 bool isMsgType( const std::string& msgType ) const
192 {
193 return m_messages.find( msgType ) != m_messages.end();
194 }
195
196 void addMsgField( const std::string& msgType, int field )
197 {
199 {
200 m_messageOrderedFields[ msgType ].push_back(field);
201 }
202
203 m_messageFields[ msgType ].insert( field );
204 }
205
206 bool isMsgField( const std::string& msgType, int field ) const
207 {
208 MsgTypeToField::const_iterator i = m_messageFields.find( msgType );
209 if ( i == m_messageFields.end() ) return false;
210 return i->second.find( field ) != i->second.end();
211 }
212
213 void addHeaderField( int field, bool required )
214 {
216 {
217 m_headerOrderedFields.push_back(field);
218 }
219
220 m_headerFields[ field ] = required;
221 }
222
223 bool isHeaderField( int field ) const
224 {
225 return m_headerFields.find( field ) != m_headerFields.end();
226 }
227
228 void addTrailerField( int field, bool required )
229 {
231 {
232 m_trailerOrderedFields.push_back(field);
233 }
234
235 m_trailerFields[ field ] = required;
236 }
237
238 bool isTrailerField( int field ) const
239 {
240 return m_trailerFields.find( field ) != m_trailerFields.end();
241 }
242
243 void addFieldType( int field, FIX::TYPE::Type type )
244 {
245 m_fieldTypes[ field ] = type;
246
247 if( type == FIX::TYPE::Data )
248 m_dataFields.insert( field );
249 }
250
251 bool getFieldType( int field, FIX::TYPE::Type& type ) const
252 {
253 FieldTypes::const_iterator i = m_fieldTypes.find( field );
254 if ( i == m_fieldTypes.end() ) return false;
255 type = i->second;
256 return true;
257 }
258
259 void addRequiredField( const std::string& msgType, int field )
260 {
261 m_requiredFields[ msgType ].insert( field );
262 }
263
264 bool isRequiredField( const std::string& msgType, int field ) const
265 {
266 MsgTypeToField::const_iterator i = m_requiredFields.find( msgType );
267 if ( i == m_requiredFields.end() ) return false;
268 return i->second.find( field ) != i->second.end();
269 }
270
271 void addFieldValue( int field, const std::string& value )
272 {
273 m_fieldValues[ field ].insert( value );
274 }
275
276 bool hasFieldValue( int field ) const
277 {
278 FieldToValue::const_iterator i = m_fieldValues.find( field );
279 return i != m_fieldValues.end();
280 }
281
282 bool isFieldValue( int field, const std::string& value ) const
283 {
284 FieldToValue::const_iterator i = m_fieldValues.find( field );
285 if ( i == m_fieldValues.end() )
286 return false;
287 if( !isMultipleValueField( field ) )
288 return i->second.find( value ) != i->second.end();
289
290 // MultipleValue
291 std::string::size_type startPos = 0;
292 std::string::size_type endPos = 0;
293 do
294 {
295 endPos = value.find_first_of(' ', startPos);
296 std::string singleValue =
297 value.substr( startPos, endPos - startPos );
298 if( i->second.find( singleValue ) == i->second.end() )
299 return false;
300 startPos = endPos + 1;
301 } while( endPos != std::string::npos );
302 return true;
303 }
304
305 void addGroup( const std::string& msg, int field, int delim,
306 const DataDictionary& dataDictionary )
307 {
308 DataDictionary * pDD = new DataDictionary( dataDictionary );
309 pDD->setVersion( getVersion() );
310
311 FieldPresenceMap& presenceMap = m_groups[ field ];
312 presenceMap[ msg ] = std::make_pair( delim, pDD );
313 }
314
315 bool isGroup( const std::string& msg, int field ) const
316 {
317 FieldToGroup::const_iterator i = m_groups.find( field );
318 if ( i == m_groups.end() ) return false;
319
320 const FieldPresenceMap& presenceMap = i->second;
321
322 FieldPresenceMap::const_iterator iter = presenceMap.find( msg );
323 return ( iter != presenceMap.end() );
324 }
325
326 bool getGroup( const std::string& msg, int field, int& delim,
327 const DataDictionary*& pDataDictionary ) const
328 {
329 FieldToGroup::const_iterator i = m_groups.find( field );
330 if ( i == m_groups.end() ) return false;
331
332 const FieldPresenceMap& presenceMap = i->second;
333
334 FieldPresenceMap::const_iterator iter = presenceMap.find( msg );
335 if( iter == presenceMap.end() ) return false;
336
337 std::pair < int, DataDictionary* > pair = iter->second;
338 delim = pair.first;
339 pDataDictionary = pair.second;
340 return true;
341 }
342
343 bool isDataField( int field ) const
344 {
345 MsgFields::const_iterator iter = m_dataFields.find( field );
346 return iter != m_dataFields.end();
347 }
348
349 bool isMultipleValueField( int field ) const
350 {
351 FieldTypes::const_iterator i = m_fieldTypes.find( field );
352 return i != m_fieldTypes.end()
353 && (i->second == TYPE::MultipleValueString
354 || i->second == TYPE::MultipleCharValue
355 || i->second == TYPE::MultipleStringValue );
356 }
357
358 void checkFieldsOutOfOrder( bool value )
359 { m_checkFieldsOutOfOrder = value; }
360 void checkFieldsHaveValues( bool value )
361 { m_checkFieldsHaveValues = value; }
362 void checkUserDefinedFields( bool value )
363 { m_checkUserDefinedFields = value; }
364 void allowUnknownMsgFields( bool value )
365 { m_allowUnknownMessageFields = value; }
366 void preserveMessageFieldsOrder( bool value )
367 { m_storeMsgFieldsOrder = value; }
370
372 static void validate( const Message& message,
373 const DataDictionary* const pSessionDD,
374 const DataDictionary* const pAppID ) throw( FIX::Exception );
375
376 void validate( const Message& message ) const throw ( FIX::Exception )
377 { validate( message, false ); }
378 void validate( const Message& message, bool bodyOnly ) const throw( FIX::Exception )
379 { validate( message, bodyOnly ? (DataDictionary*)0 : this, this ); }
380
382
383private:
385 void iterate( const FieldMap& map, const MsgType& msgType ) const;
386
388 void checkMsgType( const MsgType& msgType ) const
389 {
390 if ( !isMsgType( msgType.getValue() ) )
391 throw InvalidMessageType();
392 }
393
395 bool shouldCheckTag( const FieldBase& field ) const
396 {
398 return false;
399 else if( !m_checkUserDefinedFields && field.getTag() >= FIELD::UserMin )
400 return false;
401 else
402 return true;
403 }
404
406 void checkValidTagNumber( const FieldBase& field ) const
407 throw( InvalidTagNumber )
408 {
409 if( m_fields.find( field.getTag() ) == m_fields.end() )
410 throw InvalidTagNumber( field.getTag() );
411 }
412
413 void checkValidFormat( const FieldBase& field ) const
414 throw( IncorrectDataFormat )
415 {
416 try
417 {
419 getFieldType( field.getTag(), type );
420 switch ( type )
421 {
422 case TYPE::String:
423 STRING_CONVERTOR::convert( field.getString() ); break;
424 case TYPE::Char:
425 CHAR_CONVERTOR::convert( field.getString() ); break;
426 case TYPE::Price:
427 PRICE_CONVERTOR::convert( field.getString() ); break;
428 case TYPE::Int:
429 INT_CONVERTOR::convert( field.getString() ); break;
430 case TYPE::Amt:
431 AMT_CONVERTOR::convert( field.getString() ); break;
432 case TYPE::Qty:
433 QTY_CONVERTOR::convert( field.getString() ); break;
434 case TYPE::Currency:
435 CURRENCY_CONVERTOR::convert( field.getString() ); break;
437 MULTIPLEVALUESTRING_CONVERTOR::convert( field.getString() ); break;
439 MULTIPLESTRINGVALUE_CONVERTOR::convert( field.getString() ); break;
441 MULTIPLECHARVALUE_CONVERTOR::convert( field.getString() ); break;
442 case TYPE::Exchange:
443 EXCHANGE_CONVERTOR::convert( field.getString() ); break;
445 UTCTIMESTAMP_CONVERTOR::convert( field.getString() ); break;
446 case TYPE::Boolean:
447 BOOLEAN_CONVERTOR::convert( field.getString() ); break;
449 LOCALMKTDATE_CONVERTOR::convert( field.getString() ); break;
450 case TYPE::Data:
451 DATA_CONVERTOR::convert( field.getString() ); break;
452 case TYPE::Float:
453 FLOAT_CONVERTOR::convert( field.getString() ); break;
455 PRICEOFFSET_CONVERTOR::convert( field.getString() ); break;
456 case TYPE::MonthYear:
457 MONTHYEAR_CONVERTOR::convert( field.getString() ); break;
458 case TYPE::DayOfMonth:
459 DAYOFMONTH_CONVERTOR::convert( field.getString() ); break;
460 case TYPE::UtcDate:
461 UTCDATE_CONVERTOR::convert( field.getString() ); break;
463 UTCTIMEONLY_CONVERTOR::convert( field.getString() ); break;
464 case TYPE::NumInGroup:
465 NUMINGROUP_CONVERTOR::convert( field.getString() ); break;
466 case TYPE::Percentage:
467 PERCENTAGE_CONVERTOR::convert( field.getString() ); break;
468 case TYPE::SeqNum:
469 SEQNUM_CONVERTOR::convert( field.getString() ); break;
470 case TYPE::Length:
471 LENGTH_CONVERTOR::convert( field.getString() ); break;
472 case TYPE::Country:
473 COUNTRY_CONVERTOR::convert( field.getString() ); break;
474 case TYPE::TzTimeOnly:
475 TZTIMEONLY_CONVERTOR::convert( field.getString() ); break;
477 TZTIMESTAMP_CONVERTOR::convert( field.getString() ); break;
478 case TYPE::XmlData:
479 XMLDATA_CONVERTOR::convert( field.getString() ); break;
480 case TYPE::Language:
481 LANGUAGE_CONVERTOR::convert( field.getString() ); break;
482 case TYPE::Unknown: break;
483 }
484 }
485 catch ( FieldConvertError& )
486 { throw IncorrectDataFormat( field.getTag(), field.getString() ); }
487 }
488
489 void checkValue( const FieldBase& field ) const
490 throw( IncorrectTagValue )
491 {
492 if ( !hasFieldValue( field.getTag() ) ) return ;
493
494 const std::string& value = field.getString();
495 if ( !isFieldValue( field.getTag(), value ) )
496 throw IncorrectTagValue( field.getTag() );
497 }
498
500 void checkHasValue( const FieldBase& field ) const
501 throw( NoTagValue )
502 {
503 if ( m_checkFieldsHaveValues && !field.getString().length() )
504 throw NoTagValue( field.getTag() );
505 }
506
509 ( const FieldBase& field, const MsgType& msgType ) const
511 {
512 if ( !isMsgField( msgType, field.getTag() ) )
513 throw TagNotDefinedForMessage( field.getTag() );
514 }
515
518 ( const FieldBase& field, const FieldMap& fieldMap, const MsgType& msgType ) const
520 {
521 int fieldNum = field.getTag();
522 if( isGroup(msgType, fieldNum) )
523 {
524 if( (int)fieldMap.groupCount(fieldNum)
525 != IntConvertor::convert(field.getString()) )
526 throw RepeatingGroupCountMismatch(fieldNum);
527 }
528 }
529
532 ( const FieldMap& header, const FieldMap& body, const FieldMap& trailer,
533 const MsgType& msgType ) const
534 throw( RequiredTagMissing )
535 {
536 NonBodyFields::const_iterator iNBF;
537 for( iNBF = m_headerFields.begin(); iNBF != m_headerFields.end(); ++iNBF )
538 {
539 if( iNBF->second == true && !header.isSetField(iNBF->first) )
540 throw RequiredTagMissing( iNBF->first );
541 }
542
543 for( iNBF = m_trailerFields.begin(); iNBF != m_trailerFields.end(); ++iNBF )
544 {
545 if( iNBF->second == true && !trailer.isSetField(iNBF->first) )
546 throw RequiredTagMissing( iNBF->first );
547 }
548
549 MsgTypeToField::const_iterator iM
550 = m_requiredFields.find( msgType.getString() );
551 if ( iM == m_requiredFields.end() ) return ;
552
553 const MsgFields& fields = iM->second;
554 MsgFields::const_iterator iF;
555 for( iF = fields.begin(); iF != fields.end(); ++iF )
556 {
557 if( !body.isSetField(*iF) )
558 throw RequiredTagMissing( *iF );
559 }
560
562 for( groups = body.g_begin(); groups != body.g_end(); ++groups )
563 {
564 int delim;
565 const DataDictionary* DD = 0;
566 int field = groups->first;
567 if( getGroup( msgType.getValue(), field, delim, DD ) )
568 {
569 std::vector<FieldMap*>::const_iterator group;
570 for( group = groups->second.begin(); group != groups->second.end(); ++group )
571 DD->checkHasRequired( **group, **group, **group, msgType );
572 }
573 }
574 }
575
577 int lookupXMLFieldNumber( DOMDocument*, const std::string& name ) const;
578 int addXMLComponentFields( DOMDocument*, DOMNode*, const std::string& msgtype, DataDictionary&, bool );
579 void addXMLGroup( DOMDocument*, DOMNode*, const std::string& msgtype, DataDictionary&, bool );
580 TYPE::Type XMLTypeToType( const std::string& xmlType ) const;
581
588
589 BeginString m_beginString;
610};
611}
612
613#endif //FIX_DATADICTIONARY_H
Interface that represents document of underlying XML parser.
Definition DOMDocument.h:63
Interface that represents node from underlying XML parser.
Definition DOMDocument.h:49
Represents a data dictionary for a version of FIX.
void checkValue(const FieldBase &field) const
OrderedFieldsArray m_orderedFieldsArray
void preserveMessageFieldsOrder(bool value)
void addRequiredField(const std::string &msgType, int field)
OrderedFields m_headerOrderedFields
void checkMsgType(const MsgType &msgType) const
Check if message type is defined in spec.
std::set< int > Fields
bool isFieldValue(int field, const std::string &value) const
DataDictionary & operator=(const DataDictionary &rhs)
void readFromURL(const std::string &url)
void addValueName(int field, const std::string &value, const std::string &name)
bool isMsgField(const std::string &msgType, int field) const
std::map< std::string, int > NameToField
message_order const & getTrailerOrderedFields() const
bool isHeaderField(int field) const
std::map< std::string, MessageFieldsOrderHolder > MsgTypeToOrderedFields
OrderedFieldsArray m_trailerOrder
bool hasFieldValue(int field) const
bool isMsgType(const std::string &msgType) const
bool getValueName(int field, const std::string &value, std::string &name) const
bool getFieldName(int field, std::string &name) const
void addMsgField(const std::string &msgType, int field)
void addMsgType(const std::string &msgType)
void addField(int field)
std::set< std::string > Values
bool shouldCheckTag(const FieldBase &field) const
If we need to check for the tag in the dictionary.
void allowUnknownMsgFields(bool value)
OrderedFields m_trailerOrderedFields
int addXMLComponentFields(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
std::map< std::string, std::pair< int, DataDictionary * > > FieldPresenceMap
std::map< int, TYPE::Type > FieldTypes
void checkGroupCount(const FieldBase &field, const FieldMap &fieldMap, const MsgType &msgType) const
Check if group count matches number of groups in.
std::set< int > MsgFields
void checkHasRequired(const FieldMap &header, const FieldMap &body, const FieldMap &trailer, const MsgType &msgType) const
Check if a message has all required fields.
OrderedFields m_orderedFields
void checkIsInMessage(const FieldBase &field, const MsgType &msgType) const
Check if a field is in this message type.
void addFieldValue(int field, const std::string &value)
bool isMessageFieldsOrderPreserved() const
std::vector< int > OrderedFields
TYPE::Type XMLTypeToType(const std::string &xmlType) const
std::string getVersion() const
void readFromStream(std::istream &stream)
OrderedFieldsArray m_headerOrder
void checkFieldsHaveValues(bool value)
std::map< int, FieldPresenceMap > FieldToGroup
void addGroup(const std::string &msg, int field, int delim, const DataDictionary &dataDictionary)
bool isGroup(const std::string &msg, int field) const
message_order OrderedFieldsArray
static void validate(const Message &message, const DataDictionary *const pSessionDD, const DataDictionary *const pAppID)
Validate a message.
void validate(const Message &message, bool bodyOnly) const
bool isMultipleValueField(int field) const
FieldToValue m_fieldValues
void addFieldType(int field, FIX::TYPE::Type type)
MsgTypeToField m_requiredFields
void addHeaderField(int field, bool required)
bool isField(int field) const
bool isDataField(int field) const
void checkValidTagNumber(const FieldBase &field) const
Check if field tag number is defined in spec.
std::map< std::pair< int, std::string >, std::string > ValueToName
void checkUserDefinedFields(bool value)
std::map< int, bool > NonBodyFields
bool getGroup(const std::string &msg, int field, int &delim, const DataDictionary *&pDataDictionary) const
message_order const & getOrderedFields() const
void validate(const Message &message) const
void setVersion(const std::string &beginString)
void readFromDocument(const DOMDocumentPtr &pDoc)
BeginString m_beginString
void addFieldName(int field, const std::string &name)
message_order const & getHeaderOrderedFields() const
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const
MsgTypeToField m_messageFields
void iterate(const FieldMap &map, const MsgType &msgType) const
Iterate through fields while applying checks.
MsgTypeToOrderedFields m_messageOrderedFields
void addTrailerField(int field, bool required)
bool getFieldType(int field, FIX::TYPE::Type &type) const
bool getFieldTag(const std::string &name, int &field) const
bool isRequiredField(const std::string &msgType, int field) const
void checkHasValue(const FieldBase &field) const
Check if a field has a value.
std::set< std::string > MsgTypes
NonBodyFields m_headerFields
std::map< int, Values > FieldToValue
message_order const & getMessageOrderedFields(const std::string &msgType) const
void addXMLGroup(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
void checkFieldsOutOfOrder(bool value)
std::map< int, std::string > FieldToName
bool isTrailerField(int field) const
NonBodyFields m_trailerFields
std::map< std::string, MsgFields > MsgTypeToField
void checkValidFormat(const FieldBase &field) const
Base representation of all Field classes.
Definition Field.h:50
int getTag() const
Get the fields integer tag.
Definition Field.h:144
Stores and organizes a collection of Fields.
Definition FieldMap.h:47
Groups::const_iterator g_const_iterator
Definition FieldMap.h:102
Base class for all FIX messages.
Definition Message.h:118
const int UserMin
@ MultipleValueString
Definition FieldTypes.h:919
@ MultipleStringValue
Definition FieldTypes.h:920
@ MultipleCharValue
Definition FieldTypes.h:921
SmartPtr< DOMDocument > DOMDocumentPtr
Definition DOMDocument.h:73
static std::string convert(bool value)
static std::string convert(char value)
Application is not configured correctly
Definition Exceptions.h:88
const message_order & getMessageOrder() const
static std::string convert(double value, int padding=0)
static const std::string & convert(const std::string &value)
Base QuickFIX exception type.
Definition Exceptions.h:34
Unable to convert field into its native format.
Definition Exceptions.h:67
Field has a badly formatted value.
Definition Exceptions.h:147
Field has a value that is out of range.
Definition Exceptions.h:138
static std::string convert(signed_int value)
Not a known message type.
Definition Exceptions.h:170
Tag number does not exist in specification.
Definition Exceptions.h:102
Field exists in message without a value.
Definition Exceptions.h:129
Repeated group count not equal to actual count.
Definition Exceptions.h:209
Required field is not in message.
Definition Exceptions.h:111
Field does not belong to message.
Definition Exceptions.h:120
static std::string convert(const UtcDate &value)
static std::string convert(const UtcTimeOnly &value, int precision=0)
static std::string convert(const UtcTimeStamp &value, int precision=0)
Sorts fields in header, normal, or trailer order.

Generated on Mon Mar 4 2024 21:10:02 for QuickFIX by doxygen 1.9.8 written by Dimitri van Heesch, © 1997-2001