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 
37 namespace FIX
38 {
39 class FieldMap;
40 class Message;
41 
49 class DataDictionary
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 
58  struct MessageFieldsOrderHolder
59  {
61  {}
62 
64  {}
65 
66  void push_back(int field)
67  {
68  m_orderedFlds.push_back(field);
69  }
70 
72  {
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 
91  mutable message_order m_msgOrder;
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 
112 public:
113  DataDictionary();
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; }
368  bool isMessageFieldsOrderPreserved() const
369  { return m_storeMsgFieldsOrder; }
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 
383 private:
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  {
418  TYPE::Type type = TYPE::Unknown;
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;
444  case TYPE::UtcTimeStamp:
445  UTCTIMESTAMP_CONVERTOR::convert( field.getString() ); break;
446  case TYPE::Boolean:
447  BOOLEAN_CONVERTOR::convert( field.getString() ); break;
448  case TYPE::LocalMktDate:
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;
454  case TYPE::PriceOffset:
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;
462  case TYPE::UtcTimeOnly:
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;
476  case TYPE::TzTimeStamp:
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 
508  void checkIsInMessage
509  ( const FieldBase& field, const MsgType& msgType ) const
510  throw( TagNotDefinedForMessage )
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()) )
527  }
528  }
529 
531  void checkHasRequired
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 
576  int lookupXMLFieldNumber( DOMDocument*, DOMNode* ) const;
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 
582  bool m_hasVersion;
588 
589  BeginString m_beginString;
610 };
611 }
612 
613 #endif //FIX_DATADICTIONARY_H
FIX::DataDictionary::addFieldValue
void addFieldValue(int field, const std::string &value)
Definition: DataDictionary.h:288
FIX::DataDictionary::m_orderedFieldsArray
OrderedFieldsArray m_orderedFieldsArray
Definition: DataDictionary.h:612
FIX::FieldMap
Stores and organizes a collection of Fields.
Definition: FieldMap.h:63
FIX::DataDictionary::isMsgType
bool isMsgType(const std::string &msgType) const
Definition: DataDictionary.h:208
FIX::DataDictionary::m_checkFieldsHaveValues
bool m_checkFieldsHaveValues
Definition: DataDictionary.h:601
FIX::DataDictionary::checkGroupCount
void checkGroupCount(const FieldBase &field, const FieldMap &fieldMap, const MsgType &msgType) const
Check if group count matches number of groups in.
Definition: DataDictionary.h:535
FIX::DataDictionary::setVersion
void setVersion(const std::string &beginString)
Definition: DataDictionary.h:146
Fields.h
FIX::DataDictionary::m_trailerFields
NonBodyFields m_trailerFields
Definition: DataDictionary.h:614
FIX::DataDictionary::m_orderedFields
OrderedFields m_orderedFields
Definition: DataDictionary.h:611
FIX::DataDictionary::getValueName
bool getValueName(int field, const std::string &value, std::string &name) const
Definition: DataDictionary.h:190
FIX::DataDictionary::getTrailerOrderedFields
message_order const & getTrailerOrderedFields() const
Definition: DataDictionary.cpp:478
FIX::DataDictionary::readFromDocument
void readFromDocument(const DOMDocumentPtr &pDoc)
Definition: DataDictionary.cpp:234
FIX::DataDictionary::isField
bool isField(int field) const
Definition: DataDictionary.h:198
FIX::TYPE::LocalMktDate
@ LocalMktDate
Definition: FieldTypes.h:942
FIX::DataDictionary::MsgTypeToField
std::map< std::string, MsgFields > MsgTypeToField
Definition: DataDictionary.h:69
FIX::TYPE::SeqNum
@ SeqNum
Definition: FieldTypes.h:953
FIX::TYPE::Percentage
@ Percentage
Definition: FieldTypes.h:952
FIX::DataDictionary::checkIsInMessage
void checkIsInMessage(const FieldBase &field, const MsgType &msgType) const
Check if a field is in this message type.
Definition: DataDictionary.h:526
FIX::TYPE::UtcDate
@ UtcDate
Definition: FieldTypes.h:948
FIX::DataDictionary::readFromStream
void readFromStream(std::istream &stream)
Definition: DataDictionary.cpp:223
FIX::Exception
Base QuickFIX exception type.
Definition: Exceptions.h:50
FIX::DataDictionary::MsgFields
std::set< int > MsgFields
Definition: DataDictionary.h:68
FIX::CharConvertor::convert
static std::string convert(char value)
Definition: FieldConvertors.h:391
FIX::TYPE::PriceOffset
@ PriceOffset
Definition: FieldTypes.h:945
FIX::TYPE::Price
@ Price
Definition: FieldTypes.h:931
FIX::DataDictionary::hasFieldValue
bool hasFieldValue(int field) const
Definition: DataDictionary.h:293
FIX::DataDictionary::preserveMessageFieldsOrder
void preserveMessageFieldsOrder(bool value)
Definition: DataDictionary.h:383
FIX::TYPE::Char
@ Char
Definition: FieldTypes.h:930
FIX::DataDictionary::getGroup
bool getGroup(const std::string &msg, int field, int &delim, const DataDictionary *&pDataDictionary) const
Definition: DataDictionary.h:343
FIX::DataDictionary::m_dataFields
MsgFields m_dataFields
Definition: DataDictionary.h:621
FIX::TYPE::NumInGroup
@ NumInGroup
Definition: FieldTypes.h:951
FIX::DataDictionary::getMessageOrderedFields
message_order const & getMessageOrderedFields(const std::string &msgType) const
Definition: DataDictionary.cpp:498
FIX::DataDictionary::checkFieldsOutOfOrder
void checkFieldsOutOfOrder(bool value)
Definition: DataDictionary.h:375
FIX::TYPE::Int
@ Int
Definition: FieldTypes.h:932
FIX::DataDictionary::m_storeMsgFieldsOrder
bool m_storeMsgFieldsOrder
Definition: DataDictionary.h:604
FIX::DataDictionary::FieldToValue
std::map< int, Values > FieldToValue
Definition: DataDictionary.h:117
FIX::DataDictionary::m_trailerOrderedFields
OrderedFields m_trailerOrderedFields
Definition: DataDictionary.h:624
FIX::DataDictionary::checkUserDefinedFields
void checkUserDefinedFields(bool value)
Definition: DataDictionary.h:379
FIX::DataDictionary::MessageFieldsOrderHolder::m_msgOrder
message_order m_msgOrder
Definition: DataDictionary.h:108
FIX::TYPE::MultipleValueString
@ MultipleValueString
Definition: FieldTypes.h:936
FIX::DataDictionary::operator=
DataDictionary & operator=(const DataDictionary &rhs)
Definition: DataDictionary.cpp:80
FIX::TYPE::DayOfMonth
@ DayOfMonth
Definition: FieldTypes.h:947
FIX::DataDictionary::m_beginString
BeginString m_beginString
Definition: DataDictionary.h:606
FIX::DataDictionary::addTrailerField
void addTrailerField(int field, bool required)
Definition: DataDictionary.h:245
FIX::TYPE::Boolean
@ Boolean
Definition: FieldTypes.h:941
FIX::DataDictionary::m_fieldValues
FieldToValue m_fieldValues
Definition: DataDictionary.h:616
DOMDocument.h
FIX::DataDictionary::FieldToGroup
std::map< int, FieldPresenceMap > FieldToGroup
Definition: DataDictionary.h:127
FIX::DataDictionary::isHeaderField
bool isHeaderField(int field) const
Definition: DataDictionary.h:240
FIX::ConfigError
Application is not configured correctly
Definition: Exceptions.h:104
FIX::DataDictionary::m_checkFieldsOutOfOrder
bool m_checkFieldsOutOfOrder
Definition: DataDictionary.h:600
FIX::DataDictionary::isMsgField
bool isMsgField(const std::string &msgType, int field) const
Definition: DataDictionary.h:223
FIX::TYPE::TzTimeStamp
@ TzTimeStamp
Definition: FieldTypes.h:957
FIX::InvalidMessageType
Not a known message type.
Definition: Exceptions.h:186
FIX::DataDictionary::isRequiredField
bool isRequiredField(const std::string &msgType, int field) const
Definition: DataDictionary.h:281
FIX::UtcDateConvertor::convert
static std::string convert(const UtcDate &value)
Definition: FieldConvertors.h:652
FIX::DataDictionary::m_messages
MsgTypes m_messages
Definition: DataDictionary.h:609
FIX::DataDictionary::addValueName
void addValueName(int field, const std::string &value, const std::string &name)
Definition: DataDictionary.h:185
FIX::DataDictionary::Fields
std::set< int > Fields
Definition: DataDictionary.h:71
FIX::DataDictionary::readFromURL
void readFromURL(const std::string &url)
Definition: DataDictionary.cpp:205
FIX::DataDictionary::OrderedFieldsArray
message_order OrderedFieldsArray
Definition: DataDictionary.h:114
FIX::DataDictionary::m_names
NameToField m_names
Definition: DataDictionary.h:618
FIX::DataDictionary::m_allowUnknownMessageFields
bool m_allowUnknownMessageFields
Definition: DataDictionary.h:603
FIX::TYPE::Currency
@ Currency
Definition: FieldTypes.h:935
FIX::DataDictionary::m_messageOrderedFields
MsgTypeToOrderedFields m_messageOrderedFields
Definition: DataDictionary.h:626
FIX::DataDictionary::m_trailerOrder
OrderedFieldsArray m_trailerOrder
Definition: DataDictionary.h:625
FIX::TYPE::UtcTimeStamp
@ UtcTimeStamp
Definition: FieldTypes.h:940
FIX::RequiredTagMissing
Required field is not in message.
Definition: Exceptions.h:127
FIX::IntConvertor::convert
static std::string convert(signed_int value)
Definition: FieldConvertors.h:170
FIX::DataDictionary::FieldToName
std::map< int, std::string > FieldToName
Definition: DataDictionary.h:118
FIX::DataDictionary::addXMLGroup
void addXMLGroup(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
Definition: DataDictionary.cpp:589
FIX::TYPE::Language
@ Language
Definition: FieldTypes.h:959
FIX::DataDictionary::checkValidTagNumber
void checkValidTagNumber(const FieldBase &field) const
Check if field tag number is defined in spec.
Definition: DataDictionary.h:423
FIX::TYPE::Amt
@ Amt
Definition: FieldTypes.h:933
FIX::DataDictionary::addField
void addField(int field)
Definition: DataDictionary.h:156
FIX::TYPE::Float
@ Float
Definition: FieldTypes.h:944
FIX::DataDictionary::isTrailerField
bool isTrailerField(int field) const
Definition: DataDictionary.h:255
FIX::DataDictionary::isMessageFieldsOrderPreserved
bool isMessageFieldsOrderPreserved() const
Definition: DataDictionary.h:385
FIX::DataDictionary::getHeaderOrderedFields
message_order const & getHeaderOrderedFields() const
Definition: DataDictionary.cpp:458
FIX::DataDictionary::m_valueNames
ValueToName m_valueNames
Definition: DataDictionary.h:619
FIX::DataDictionary::getOrderedFields
message_order const & getOrderedFields() const
Definition: DataDictionary.cpp:441
FIX::DataDictionary::m_messageFields
MsgTypeToField m_messageFields
Definition: DataDictionary.h:607
FIX::FieldBase::getTag
int getTag() const
Get the fields integer tag.
Definition: Field.h:178
FIX::DataDictionary::m_headerOrderedFields
OrderedFields m_headerOrderedFields
Definition: DataDictionary.h:622
FIX::DataDictionary::isFieldValue
bool isFieldValue(int field, const std::string &value) const
Definition: DataDictionary.h:299
FIX::DataDictionary::addFieldName
void addFieldName(int field, const std::string &name)
Definition: DataDictionary.h:162
FIX::DataDictionary::addMsgType
void addMsgType(const std::string &msgType)
Definition: DataDictionary.h:203
FIX::DataDictionary::addXMLComponentFields
int addXMLComponentFields(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
Definition: DataDictionary.cpp:525
FIX::TYPE::UtcTimeOnly
@ UtcTimeOnly
Definition: FieldTypes.h:950
FIX::InvalidTagNumber
Tag number does not exist in specification.
Definition: Exceptions.h:118
FIX::DataDictionary::lookupXMLFieldNumber
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const
Definition: DataDictionary.cpp:507
FieldMap.h
FIX::DataDictionary::MessageFieldsOrderHolder::~MessageFieldsOrderHolder
~MessageFieldsOrderHolder()
Definition: DataDictionary.h:80
FIX::TYPE::String
@ String
Definition: FieldTypes.h:929
FIX::DataDictionary::isMultipleValueField
bool isMultipleValueField(int field) const
Definition: DataDictionary.h:366
FIX::DataDictionary::FieldPresenceMap
std::map< std::string, std::pair< int, DataDictionary * > > FieldPresenceMap
Definition: DataDictionary.h:126
FIX::DataDictionary::XMLTypeToType
TYPE::Type XMLTypeToType(const std::string &xmlType) const
Definition: DataDictionary.cpp:646
FIX::DataDictionary::validate
static void validate(const Message &message, const DataDictionary *const pSessionDD, const DataDictionary *const pAppID)
Validate a message.
Definition: DataDictionary.cpp:123
FIX::TYPE::Length
@ Length
Definition: FieldTypes.h:954
FIX::UtcTimeStampConvertor::convert
static std::string convert(const UtcTimeStamp &value, int precision=0)
Definition: FieldConvertors.h:451
FIX::DataDictionary::addHeaderField
void addHeaderField(int field, bool required)
Definition: DataDictionary.h:230
FIX::DataDictionary::m_groups
FieldToGroup m_groups
Definition: DataDictionary.h:620
FIX::DataDictionary::checkFieldsHaveValues
void checkFieldsHaveValues(bool value)
Definition: DataDictionary.h:377
FIX::DataDictionary::shouldCheckTag
bool shouldCheckTag(const FieldBase &field) const
If we need to check for the tag in the dictionary.
Definition: DataDictionary.h:412
FIX::FieldMap::g_const_iterator
Groups::const_iterator g_const_iterator
Definition: FieldMap.h:136
FIX::TYPE::XmlData
@ XmlData
Definition: FieldTypes.h:958
FIX::DataDictionary::m_fieldTypes
FieldTypes m_fieldTypes
Definition: DataDictionary.h:615
FIX::DOMDocumentPtr
SmartPtr< DOMDocument > DOMDocumentPtr
Definition: DOMDocument.h:73
FIX::Message
Base class for all FIX messages.
Definition: Message.h:134
FIX::TYPE::Data
@ Data
Definition: FieldTypes.h:943
FIX::BoolConvertor::convert
static std::string convert(bool value)
Definition: FieldConvertors.h:418
FIX::DataDictionary::NameToField
std::map< std::string, int > NameToField
Definition: DataDictionary.h:119
FIX::TYPE::Exchange
@ Exchange
Definition: FieldTypes.h:939
FIX
Definition: Acceptor.cpp:34
FIX::DataDictionary::checkHasRequired
void checkHasRequired(const FieldMap &header, const FieldMap &body, const FieldMap &trailer, const MsgType &msgType) const
Check if a message has all required fields.
Definition: DataDictionary.h:549
FIX::DataDictionary::isGroup
bool isGroup(const std::string &msg, int field) const
Definition: DataDictionary.h:332
FIX::DataDictionary
Represents a data dictionary for a version of FIX.
Definition: DataDictionary.h:66
FIX::DataDictionary::addFieldType
void addFieldType(int field, FIX::TYPE::Type type)
Definition: DataDictionary.h:260
FIX::DataDictionary::OrderedFields
std::vector< int > OrderedFields
Definition: DataDictionary.h:73
FIX::DataDictionary::getFieldTag
bool getFieldTag(const std::string &name, int &field) const
Definition: DataDictionary.h:177
FIX::DataDictionary::m_hasVersion
bool m_hasVersion
Definition: DataDictionary.h:599
FIX::EmptyConvertor::convert
static const std::string & convert(const std::string &value)
Definition: FieldConvertors.h:161
FIX::TYPE::MonthYear
@ MonthYear
Definition: FieldTypes.h:946
FIX::TYPE::TzTimeOnly
@ TzTimeOnly
Definition: FieldTypes.h:956
FIX::FIELD::UserMin
const int UserMin
Definition: FieldNumbers.h:74
FIX::DataDictionary::MessageFieldsOrderHolder::m_orderedFlds
OrderedFields m_orderedFlds
Definition: DataDictionary.h:109
FIX::DataDictionary::checkHasValue
void checkHasValue(const FieldBase &field) const
Check if a field has a value.
Definition: DataDictionary.h:517
FIX::DataDictionary::checkValue
void checkValue(const FieldBase &field) const
Definition: DataDictionary.h:506
FIX::RepeatingGroupCountMismatch
Repeated group count not equal to actual count.
Definition: Exceptions.h:225
FIX::DataDictionary::getVersion
std::string getVersion() const
Definition: DataDictionary.h:151
FIX::DataDictionary::m_checkUserDefinedFields
bool m_checkUserDefinedFields
Definition: DataDictionary.h:602
FIX::DataDictionary::Values
std::set< std::string > Values
Definition: DataDictionary.h:116
FIX::DataDictionary::m_requiredFields
MsgTypeToField m_requiredFields
Definition: DataDictionary.h:608
FIX::TYPE::Unknown
@ Unknown
Definition: FieldTypes.h:928
FIX::FieldBase
Base representation of all Field classes.
Definition: Field.h:66
FIX::TYPE::Qty
@ Qty
Definition: FieldTypes.h:934
FIX::DataDictionary::MessageFieldsOrderHolder::getMessageOrder
const message_order & getMessageOrder() const
Definition: DataDictionary.h:88
FIX::DataDictionary::checkMsgType
void checkMsgType(const MsgType &msgType) const
Check if message type is defined in spec.
Definition: DataDictionary.h:405
Exceptions.h
FIX::TYPE::Country
@ Country
Definition: FieldTypes.h:955
FIX::DataDictionary::m_fieldNames
FieldToName m_fieldNames
Definition: DataDictionary.h:617
FIX::DoubleConvertor::convert
static std::string convert(double value, int padding=0)
Definition: FieldConvertors.h:272
FIX::DataDictionary::MessageFieldsOrderHolder::MessageFieldsOrderHolder
MessageFieldsOrderHolder()
Definition: DataDictionary.h:77
FIX::DataDictionary::addGroup
void addGroup(const std::string &msg, int field, int delim, const DataDictionary &dataDictionary)
Definition: DataDictionary.h:322
FIX::message_order
Sorts fields in header, normal, or trailer order.
Definition: MessageSorters.h:130
FIX::DataDictionary::m_headerFields
NonBodyFields m_headerFields
Definition: DataDictionary.h:613
FIX::IncorrectDataFormat
Field has a badly formatted value.
Definition: Exceptions.h:163
FIX::TagNotDefinedForMessage
Field does not belong to message.
Definition: Exceptions.h:136
FIX::DataDictionary::checkValidFormat
void checkValidFormat(const FieldBase &field) const
Definition: DataDictionary.h:430
FIX::DataDictionary::m_fields
Fields m_fields
Definition: DataDictionary.h:610
FIX::DataDictionary::addRequiredField
void addRequiredField(const std::string &msgType, int field)
Definition: DataDictionary.h:276
FIX::DataDictionary::ValueToName
std::map< std::pair< int, std::string >, std::string > ValueToName
Definition: DataDictionary.h:120
FIX::DataDictionary::iterate
void iterate(const FieldMap &map, const MsgType &msgType) const
Iterate through fields while applying checks.
Definition: DataDictionary.cpp:173
FIX::DataDictionary::getFieldName
bool getFieldName(int field, std::string &name) const
Definition: DataDictionary.h:169
FIX::DataDictionary::getFieldType
bool getFieldType(int field, FIX::TYPE::Type &type) const
Definition: DataDictionary.h:268
FIX::TYPE::Type
Type
Definition: FieldTypes.h:926
FIX::DataDictionary::MessageFieldsOrderHolder::push_back
void push_back(int field)
Definition: DataDictionary.h:83
FIX::UtcTimeOnlyConvertor::convert
static std::string convert(const UtcTimeOnly &value, int precision=0)
Definition: FieldConvertors.h:565
FIX::DataDictionary::MsgTypes
std::set< std::string > MsgTypes
Definition: DataDictionary.h:70
FIX::DataDictionary::isDataField
bool isDataField(int field) const
Definition: DataDictionary.h:360
FIX::DataDictionary::MsgTypeToOrderedFields
std::map< std::string, MessageFieldsOrderHolder > MsgTypeToOrderedFields
Definition: DataDictionary.h:112
FIX::DataDictionary::NonBodyFields
std::map< int, bool > NonBodyFields
Definition: DataDictionary.h:72
FIX::DataDictionary::allowUnknownMsgFields
void allowUnknownMsgFields(bool value)
Definition: DataDictionary.h:381
FIX::DataDictionary::DataDictionary
DataDictionary()
Definition: DataDictionary.cpp:41
FIX::DataDictionary::m_headerOrder
OrderedFieldsArray m_headerOrder
Definition: DataDictionary.h:623
FIX::DataDictionary::addMsgField
void addMsgField(const std::string &msgType, int field)
Definition: DataDictionary.h:213
FIX::TYPE::MultipleCharValue
@ MultipleCharValue
Definition: FieldTypes.h:938
FIX::DataDictionary::FieldTypes
std::map< int, TYPE::Type > FieldTypes
Definition: DataDictionary.h:115
FIX::TYPE::MultipleStringValue
@ MultipleStringValue
Definition: FieldTypes.h:937

Generated on Wed Apr 29 2020 19:41:30 for QuickFIX by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2001