Classes | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
FIX::DataDictionary Class Reference

Represents a data dictionary for a version of FIX. More...

#include <DataDictionary.h>

Collaboration diagram for FIX::DataDictionary:
Collaboration graph
[legend]

Classes

struct  MessageFieldsOrderHolder
 

Public Member Functions

 DataDictionary ()
 
 DataDictionary (const DataDictionary &copy)
 
 DataDictionary (std::istream &stream, bool preserveMsgFldsOrder=false) throw ( ConfigError )
 
 DataDictionary (const std::string &url, bool preserveMsgFldsOrder=false) throw ( ConfigError )
 
virtual ~DataDictionary ()
 
void readFromURL (const std::string &url) throw ( ConfigError )
 
void readFromDocument (const DOMDocumentPtr &pDoc) throw ( ConfigError )
 
void readFromStream (std::istream &stream) throw ( ConfigError )
 
message_order const & getOrderedFields () const
 
message_order const & getHeaderOrderedFields () const throw ( ConfigError )
 
message_order const & getTrailerOrderedFields () const throw ( ConfigError )
 
message_order const & getMessageOrderedFields (const std::string &msgType) const throw ( ConfigError )
 
void setVersion (const std::string &beginString)
 
std::string getVersion () const
 
void addField (int field)
 
void addFieldName (int field, const std::string &name)
 
bool getFieldName (int field, std::string &name) const
 
bool getFieldTag (const std::string &name, int &field) const
 
void addValueName (int field, const std::string &value, const std::string &name)
 
bool getValueName (int field, const std::string &value, std::string &name) const
 
bool isField (int field) const
 
void addMsgType (const std::string &msgType)
 
bool isMsgType (const std::string &msgType) const
 
void addMsgField (const std::string &msgType, int field)
 
bool isMsgField (const std::string &msgType, int field) const
 
void addHeaderField (int field, bool required)
 
bool isHeaderField (int field) const
 
void addTrailerField (int field, bool required)
 
bool isTrailerField (int field) const
 
void addFieldType (int field, FIX::TYPE::Type type)
 
bool getFieldType (int field, FIX::TYPE::Type &type) const
 
void addRequiredField (const std::string &msgType, int field)
 
bool isRequiredField (const std::string &msgType, int field) const
 
void addFieldValue (int field, const std::string &value)
 
bool hasFieldValue (int field) const
 
bool isFieldValue (int field, const std::string &value) const
 
void addGroup (const std::string &msg, int field, int delim, const DataDictionary &dataDictionary)
 
bool isGroup (const std::string &msg, int field) const
 
bool getGroup (const std::string &msg, int field, int &delim, const DataDictionary *&pDataDictionary) const
 
bool isDataField (int field) const
 
bool isMultipleValueField (int field) const
 
void checkFieldsOutOfOrder (bool value)
 
void checkFieldsHaveValues (bool value)
 
void checkUserDefinedFields (bool value)
 
void allowUnknownMsgFields (bool value)
 
void preserveMessageFieldsOrder (bool value)
 
bool isMessageFieldsOrderPreserved () const
 
void validate (const Message &message) const throw ( FIX::Exception )
 
void validate (const Message &message, bool bodyOnly) const throw ( FIX::Exception )
 
DataDictionaryoperator= (const DataDictionary &rhs)
 

Static Public Member Functions

static void validate (const Message &message, const DataDictionary *const pSessionDD, const DataDictionary *const pAppID) throw ( FIX::Exception )
 Validate a message. More...
 

Private Types

typedef std::set< int > MsgFields
 
typedef std::map< std::string, MsgFieldsMsgTypeToField
 
typedef std::set< std::string > MsgTypes
 
typedef std::set< int > Fields
 
typedef std::map< int, bool > NonBodyFields
 
typedef std::vector< int > OrderedFields
 
typedef std::map< std::string, MessageFieldsOrderHolderMsgTypeToOrderedFields
 
typedef message_order OrderedFieldsArray
 
typedef std::map< int, TYPE::TypeFieldTypes
 
typedef std::set< std::string > Values
 
typedef std::map< int, ValuesFieldToValue
 
typedef std::map< int, std::string > FieldToName
 
typedef std::map< std::string, int > NameToField
 
typedef std::map< std::pair< int, std::string >, std::string > ValueToName
 
typedef std::map< std::string, std::pair< int, DataDictionary * > > FieldPresenceMap
 
typedef std::map< int, FieldPresenceMapFieldToGroup
 

Private Member Functions

void iterate (const FieldMap &map, const MsgType &msgType) const
 Iterate through fields while applying checks. More...
 
void checkMsgType (const MsgType &msgType) const
 Check if message type is defined in spec. More...
 
bool shouldCheckTag (const FieldBase &field) const
 If we need to check for the tag in the dictionary. More...
 
void checkValidTagNumber (const FieldBase &field) const throw ( InvalidTagNumber )
 Check if field tag number is defined in spec. More...
 
void checkValidFormat (const FieldBase &field) const throw ( IncorrectDataFormat )
 
void checkValue (const FieldBase &field) const throw ( IncorrectTagValue )
 
void checkHasValue (const FieldBase &field) const throw ( NoTagValue )
 Check if a field has a value. More...
 
void checkIsInMessage (const FieldBase &field, const MsgType &msgType) const throw ( TagNotDefinedForMessage )
 Check if a field is in this message type. More...
 
void checkGroupCount (const FieldBase &field, const FieldMap &fieldMap, const MsgType &msgType) const throw ( RepeatingGroupCountMismatch )
 Check if group count matches number of groups in. More...
 
void checkHasRequired (const FieldMap &header, const FieldMap &body, const FieldMap &trailer, const MsgType &msgType) const throw ( RequiredTagMissing )
 Check if a message has all required fields. More...
 
int lookupXMLFieldNumber (DOMDocument *, DOMNode *) const
 
int lookupXMLFieldNumber (DOMDocument *, const std::string &name) const
 
int addXMLComponentFields (DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
 
void addXMLGroup (DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
 
TYPE::Type XMLTypeToType (const std::string &xmlType) const
 

Private Attributes

bool m_hasVersion
 
bool m_checkFieldsOutOfOrder
 
bool m_checkFieldsHaveValues
 
bool m_checkUserDefinedFields
 
bool m_allowUnknownMessageFields
 
bool m_storeMsgFieldsOrder
 
BeginString m_beginString
 
MsgTypeToField m_messageFields
 
MsgTypeToField m_requiredFields
 
MsgTypes m_messages
 
Fields m_fields
 
OrderedFields m_orderedFields
 
OrderedFieldsArray m_orderedFieldsArray
 
NonBodyFields m_headerFields
 
NonBodyFields m_trailerFields
 
FieldTypes m_fieldTypes
 
FieldToValue m_fieldValues
 
FieldToName m_fieldNames
 
NameToField m_names
 
ValueToName m_valueNames
 
FieldToGroup m_groups
 
MsgFields m_dataFields
 
OrderedFields m_headerOrderedFields
 
OrderedFieldsArray m_headerOrder
 
OrderedFields m_trailerOrderedFields
 
OrderedFieldsArray m_trailerOrder
 
MsgTypeToOrderedFields m_messageOrderedFields
 

Detailed Description

Represents a data dictionary for a version of FIX.

Generally loaded from an XML document. The DataDictionary is also responsible for validation beyond the basic structure of a message.

Definition at line 66 of file DataDictionary.h.

Member Typedef Documentation

◆ FieldPresenceMap

typedef std::map< std::string, std::pair < int, DataDictionary* > > FIX::DataDictionary::FieldPresenceMap
private

Definition at line 126 of file DataDictionary.h.

◆ Fields

typedef std::set< int > FIX::DataDictionary::Fields
private

Definition at line 71 of file DataDictionary.h.

◆ FieldToGroup

typedef std::map< int, FieldPresenceMap > FIX::DataDictionary::FieldToGroup
private

Definition at line 127 of file DataDictionary.h.

◆ FieldToName

typedef std::map< int, std::string > FIX::DataDictionary::FieldToName
private

Definition at line 118 of file DataDictionary.h.

◆ FieldToValue

typedef std::map< int, Values > FIX::DataDictionary::FieldToValue
private

Definition at line 117 of file DataDictionary.h.

◆ FieldTypes

typedef std::map< int, TYPE::Type > FIX::DataDictionary::FieldTypes
private

Definition at line 115 of file DataDictionary.h.

◆ MsgFields

typedef std::set< int > FIX::DataDictionary::MsgFields
private

Definition at line 68 of file DataDictionary.h.

◆ MsgTypes

typedef std::set< std::string > FIX::DataDictionary::MsgTypes
private

Definition at line 70 of file DataDictionary.h.

◆ MsgTypeToField

typedef std::map< std::string, MsgFields > FIX::DataDictionary::MsgTypeToField
private

Definition at line 69 of file DataDictionary.h.

◆ MsgTypeToOrderedFields

Definition at line 112 of file DataDictionary.h.

◆ NameToField

typedef std::map< std::string, int > FIX::DataDictionary::NameToField
private

Definition at line 119 of file DataDictionary.h.

◆ NonBodyFields

typedef std::map< int, bool > FIX::DataDictionary::NonBodyFields
private

Definition at line 72 of file DataDictionary.h.

◆ OrderedFields

typedef std::vector< int > FIX::DataDictionary::OrderedFields
private

Definition at line 73 of file DataDictionary.h.

◆ OrderedFieldsArray

Definition at line 114 of file DataDictionary.h.

◆ Values

typedef std::set< std::string > FIX::DataDictionary::Values
private

Definition at line 116 of file DataDictionary.h.

◆ ValueToName

typedef std::map< std::pair < int, std::string > , std::string > FIX::DataDictionary::ValueToName
private

Definition at line 120 of file DataDictionary.h.

Constructor & Destructor Documentation

◆ DataDictionary() [1/4]

FIX::DataDictionary::DataDictionary ( )

Definition at line 41 of file DataDictionary.cpp.

◆ DataDictionary() [2/4]

FIX::DataDictionary::DataDictionary ( const DataDictionary copy)

Definition at line 62 of file DataDictionary.cpp.

63 {
64  *this = copy;
65 }

◆ DataDictionary() [3/4]

FIX::DataDictionary::DataDictionary ( std::istream &  stream,
bool  preserveMsgFldsOrder = false 
)
throw (ConfigError
)

Definition at line 46 of file DataDictionary.cpp.

48 : m_hasVersion( false ), m_checkFieldsOutOfOrder( true ),
50 {
51  readFromStream( stream );
52 }

◆ DataDictionary() [4/4]

FIX::DataDictionary::DataDictionary ( const std::string &  url,
bool  preserveMsgFldsOrder = false 
)
throw (ConfigError
)

Definition at line 54 of file DataDictionary.cpp.

56 : m_hasVersion( false ), m_checkFieldsOutOfOrder( true ),
58 {
59  readFromURL( url );
60 }

◆ ~DataDictionary()

FIX::DataDictionary::~DataDictionary ( )
virtual

Definition at line 67 of file DataDictionary.cpp.

68 {
69  FieldToGroup::iterator i;
70  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
71  {
72  const FieldPresenceMap& presenceMap = i->second;
73 
74  FieldPresenceMap::const_iterator iter = presenceMap.begin();
75  for ( ; iter != presenceMap.end(); ++iter )
76  delete iter->second.second;
77  }
78 }

References m_groups.

Member Function Documentation

◆ addField()

void FIX::DataDictionary::addField ( int  field)
inline

Definition at line 156 of file DataDictionary.h.

161  {

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ addFieldName()

void FIX::DataDictionary::addFieldName ( int  field,
const std::string &  name 
)
inline

Definition at line 162 of file DataDictionary.h.

◆ addFieldType()

void FIX::DataDictionary::addFieldType ( int  field,
FIX::TYPE::Type  type 
)
inline

Definition at line 260 of file DataDictionary.h.

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 );

References m_requiredFields.

◆ addFieldValue()

void FIX::DataDictionary::addFieldValue ( int  field,
const std::string &  value 
)
inline

Definition at line 288 of file DataDictionary.h.

◆ addGroup()

void FIX::DataDictionary::addGroup ( const std::string &  msg,
int  field,
int  delim,
const DataDictionary dataDictionary 
)
inline

Definition at line 322 of file DataDictionary.h.

328  {
329  FieldToGroup::const_iterator i = m_groups.find( field );
330  if ( i == m_groups.end() ) return false;

Referenced by addXMLGroup(), and operator=().

◆ addHeaderField()

void FIX::DataDictionary::addHeaderField ( int  field,
bool  required 
)
inline

Definition at line 230 of file DataDictionary.h.

231  {
232  m_trailerOrderedFields.push_back(field);
233  }
234 
235  m_trailerFields[ field ] = required;
236  }
237 
238  bool isTrailerField( int field ) const

References m_trailerOrderedFields.

◆ addMsgField()

void FIX::DataDictionary::addMsgField ( const std::string &  msgType,
int  field 
)
inline

Definition at line 213 of file DataDictionary.h.

214  {
216  {
217  m_headerOrderedFields.push_back(field);
218  }
219 
220  m_headerFields[ field ] = required;
221  }

References m_headerFields, m_headerOrderedFields, and m_storeMsgFieldsOrder.

Referenced by addXMLComponentFields().

◆ addMsgType()

void FIX::DataDictionary::addMsgType ( const std::string &  msgType)
inline

Definition at line 203 of file DataDictionary.h.

207  {

◆ addRequiredField()

void FIX::DataDictionary::addRequiredField ( const std::string &  msgType,
int  field 
)
inline

Definition at line 276 of file DataDictionary.h.

277  {
278  FieldToValue::const_iterator i = m_fieldValues.find( field );
279  return i != m_fieldValues.end();

References m_fieldValues.

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ addTrailerField()

void FIX::DataDictionary::addTrailerField ( int  field,
bool  required 
)
inline

Definition at line 245 of file DataDictionary.h.

252  {
253  FieldTypes::const_iterator i = m_fieldTypes.find( field );

◆ addValueName()

void FIX::DataDictionary::addValueName ( int  field,
const std::string &  value,
const std::string &  name 
)
inline

Definition at line 185 of file DataDictionary.h.

187  {
188  m_messages.insert( msgType );

References m_messages.

◆ addXMLComponentFields()

int FIX::DataDictionary::addXMLComponentFields ( DOMDocument pDoc,
DOMNode pNode,
const std::string &  msgtype,
DataDictionary DD,
bool  componentRequired 
)
private

Definition at line 525 of file DataDictionary.cpp.

529 {
530  int firstField = 0;
531 
532  DOMAttributesPtr attrs = pNode->getAttributes();
533  std::string name;
534  if(!attrs->get("name", name))
535  throw ConfigError("No name given to component");
536 
537  DOMNodePtr pComponentNode =
538  pDoc->getNode("/fix/components/component[@name='" + name + "']");
539  if(pComponentNode.get() == 0)
540  throw ConfigError("Component not found: " + name);
541 
542  DOMNodePtr pComponentFieldNode = pComponentNode->getFirstChildNode();
543  while(pComponentFieldNode.get())
544  {
545  if(pComponentFieldNode->getName() == "field"
546  || pComponentFieldNode->getName() == "group")
547  {
548  DOMAttributesPtr attrs = pComponentFieldNode->getAttributes();
549  std::string name;
550  if(!attrs->get("name", name))
551  throw ConfigError("No name given to field");
552  int field = lookupXMLFieldNumber(pDoc, name);
553  if( firstField == 0 ) firstField = field;
554 
555  std::string required;
556  if(attrs->get("required", required)
557  && (required == "Y" || required =="y")
558  && componentRequired)
559  {
560  addRequiredField(msgtype, field);
561  }
562 
563  DD.addField(field);
564  DD.addMsgField(msgtype, field);
565  }
566  if(pComponentFieldNode->getName() == "component")
567  {
568  DOMAttributesPtr attrs = pComponentFieldNode->getAttributes();
569  std::string required;
570  attrs->get("required", required);
571  bool isRequired = (required == "Y" || required == "y");
572  addXMLComponentFields(pDoc, pComponentFieldNode.get(),
573  msgtype, DD, isRequired);
574  }
575  if(pComponentFieldNode->getName() == "group")
576  {
577  DOMAttributesPtr attrs = pComponentFieldNode->getAttributes();
578  std::string required;
579  attrs->get("required", required);
580  bool isRequired = (required == "Y" || required == "y");
581  addXMLGroup(pDoc, pComponentFieldNode.get(), msgtype, DD, isRequired);
582  }
583  RESET_AUTO_PTR(pComponentFieldNode,
584  pComponentFieldNode->getNextSiblingNode());
585  }
586  return firstField;
587 }

References addField(), addMsgField(), addRequiredField(), addXMLGroup(), FIX::DOMNode::getAttributes(), FIX::DOMDocument::getNode(), lookupXMLFieldNumber(), and RESET_AUTO_PTR.

Referenced by addXMLGroup().

◆ addXMLGroup()

void FIX::DataDictionary::addXMLGroup ( DOMDocument pDoc,
DOMNode pNode,
const std::string &  msgtype,
DataDictionary DD,
bool  groupRequired 
)
private

Definition at line 589 of file DataDictionary.cpp.

592 {
593  DOMAttributesPtr attrs = pNode->getAttributes();
594  std::string name;
595  if(!attrs->get("name", name))
596  throw ConfigError("No name given to group");
597  int group = lookupXMLFieldNumber( pDoc, name );
598  int delim = 0;
599  int field = 0;
600  DataDictionary groupDD;
601  DOMNodePtr node = pNode->getFirstChildNode();
602  while(node.get())
603  {
604  if( node->getName() == "field" )
605  {
606  field = lookupXMLFieldNumber( pDoc, node.get() );
607  groupDD.addField( field );
608 
609  DOMAttributesPtr attrs = node->getAttributes();
610  std::string required;
611  if( attrs->get("required", required)
612  && ( required == "Y" || required =="y" )
613  && groupRequired )
614  {
615  groupDD.addRequiredField(msgtype, field);
616  }
617  }
618  else if( node->getName() == "component" )
619  {
620  field = addXMLComponentFields( pDoc, node.get(), msgtype, groupDD, false );
621  }
622  else if( node->getName() == "group" )
623  {
624  field = lookupXMLFieldNumber( pDoc, node.get() );
625  groupDD.addField( field );
626  DOMAttributesPtr attrs = node->getAttributes();
627  std::string required;
628  if( attrs->get("required", required )
629  && ( required == "Y" || required =="y" )
630  && groupRequired)
631  {
632  groupDD.addRequiredField(msgtype, field);
633  }
634  bool isRequired = false;
635  if( attrs->get("required", required) )
636  isRequired = (required == "Y" || required == "y");
637  addXMLGroup( pDoc, node.get(), msgtype, groupDD, isRequired );
638  }
639  if( delim == 0 ) delim = field;
640  RESET_AUTO_PTR(node, node->getNextSiblingNode());
641  }
642 
643  if( delim ) DD.addGroup( msgtype, group, delim, groupDD );
644 }

References addField(), addGroup(), addRequiredField(), addXMLComponentFields(), FIX::DOMNode::getAttributes(), FIX::DOMNode::getFirstChildNode(), lookupXMLFieldNumber(), and RESET_AUTO_PTR.

Referenced by addXMLComponentFields().

◆ allowUnknownMsgFields()

void FIX::DataDictionary::allowUnknownMsgFields ( bool  value)
inline

Definition at line 381 of file DataDictionary.h.

383  :

◆ checkFieldsHaveValues()

void FIX::DataDictionary::checkFieldsHaveValues ( bool  value)
inline

Definition at line 377 of file DataDictionary.h.

377  { validate( message, false ); }
378  void validate( const Message& message, bool bodyOnly ) const throw( FIX::Exception )

References validate().

◆ checkFieldsOutOfOrder()

void FIX::DataDictionary::checkFieldsOutOfOrder ( bool  value)
inline

Definition at line 375 of file DataDictionary.h.

377  { validate( message, false ); }

◆ checkGroupCount()

void FIX::DataDictionary::checkGroupCount ( const FieldBase field,
const FieldMap fieldMap,
const MsgType &  msgType 
) const
throw (RepeatingGroupCountMismatch
)
inlineprivate

Check if group count matches number of groups in.

Definition at line 535 of file DataDictionary.h.

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) )

References m_headerFields, and m_trailerFields.

Referenced by iterate().

◆ checkHasRequired()

void FIX::DataDictionary::checkHasRequired ( const FieldMap header,
const FieldMap body,
const FieldMap trailer,
const MsgType &  msgType 
) const
throw (RequiredTagMissing
)
inlineprivate

Check if a message has all required fields.

Definition at line 549 of file DataDictionary.h.

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;

◆ checkHasValue()

void FIX::DataDictionary::checkHasValue ( const FieldBase field) const
throw (NoTagValue
)
inlineprivate

Check if a field has a value.

Definition at line 517 of file DataDictionary.h.

520  {
521  int fieldNum = field.getTag();
522  if( isGroup(msgType, fieldNum) )

References FIX::IntConvertor::convert(), and isGroup().

Referenced by iterate().

◆ checkIsInMessage()

void FIX::DataDictionary::checkIsInMessage ( const FieldBase field,
const MsgType &  msgType 
) const
throw (TagNotDefinedForMessage
)
inlineprivate

Check if a field is in this message type.

Definition at line 526 of file DataDictionary.h.

535  {

Referenced by iterate().

◆ checkMsgType()

void FIX::DataDictionary::checkMsgType ( const MsgType &  msgType) const
inlineprivate

Check if message type is defined in spec.

Definition at line 405 of file DataDictionary.h.

408  {
409  if( m_fields.find( field.getTag() ) == m_fields.end() )

◆ checkUserDefinedFields()

void FIX::DataDictionary::checkUserDefinedFields ( bool  value)
inline

Definition at line 379 of file DataDictionary.h.

379  { validate( message, bodyOnly ? (DataDictionary*)0 : this, this ); }
380 

References validate().

◆ checkValidFormat()

void FIX::DataDictionary::checkValidFormat ( const FieldBase field) const
throw (IncorrectDataFormat
)
inlineprivate

Definition at line 430 of file DataDictionary.h.

430  :
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() );

Referenced by iterate().

◆ checkValidTagNumber()

void FIX::DataDictionary::checkValidTagNumber ( const FieldBase field) const
throw (InvalidTagNumber
)
inlineprivate

Check if field tag number is defined in spec.

Definition at line 423 of file DataDictionary.h.

424  :
425  CHAR_CONVERTOR::convert( field.getString() ); break;
426  case TYPE::Price:
427  PRICE_CONVERTOR::convert( field.getString() ); break;
428  case TYPE::Int:

Referenced by iterate().

◆ checkValue()

void FIX::DataDictionary::checkValue ( const FieldBase field) const
throw (IncorrectTagValue
)
inlineprivate

Definition at line 506 of file DataDictionary.h.

511  {
512  if ( !isMsgField( msgType, field.getTag() ) )
513  throw TagNotDefinedForMessage( field.getTag() );
514  }

References isMsgField().

Referenced by iterate().

◆ getFieldName()

bool FIX::DataDictionary::getFieldName ( int  field,
std::string &  name 
) const
inline

Definition at line 169 of file DataDictionary.h.

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) );

References m_valueNames.

◆ getFieldTag()

bool FIX::DataDictionary::getFieldTag ( const std::string &  name,
int &  field 
) const
inline

Definition at line 177 of file DataDictionary.h.

182  {
183  return m_fields.find( field ) != m_fields.end();

◆ getFieldType()

bool FIX::DataDictionary::getFieldType ( int  field,
FIX::TYPE::Type type 
) const
inline

Definition at line 268 of file DataDictionary.h.

272  {
273  m_fieldValues[ field ].insert( value );
274  }

Referenced by shouldCheckTag().

◆ getGroup()

bool FIX::DataDictionary::getGroup ( const std::string &  msg,
int  field,
int &  delim,
const DataDictionary *&  pDataDictionary 
) const
inline

Definition at line 343 of file DataDictionary.h.

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 )

References m_dataFields.

◆ getHeaderOrderedFields()

message_order const & FIX::DataDictionary::getHeaderOrderedFields ( ) const
throw (ConfigError
)

Definition at line 458 of file DataDictionary.cpp.

459 {
460  if( m_headerOrder ) return m_headerOrder;
461 
462  if (m_headerOrderedFields.size() == 0)
463  throw ConfigError("<Header> does not have a stored message order");
464 
465  int * tmp = new int[m_headerOrderedFields.size() + 1];
466  int * i = tmp;
467 
468  OrderedFields::const_iterator iter;
469  for( iter = m_headerOrderedFields.begin(); iter != m_headerOrderedFields.end(); *(i++) = *(iter++) ) {}
470  *i = 0;
471 
472  m_headerOrder = message_order(tmp);
473  delete [] tmp;
474 
475  return m_headerOrder;
476 }

References m_headerOrder, and m_headerOrderedFields.

◆ getMessageOrderedFields()

const message_order & FIX::DataDictionary::getMessageOrderedFields ( const std::string &  msgType) const
throw (ConfigError
)

Definition at line 498 of file DataDictionary.cpp.

499 {
500  MsgTypeToOrderedFields::const_iterator iter = m_messageOrderedFields.find(msgType);
501  if (iter == m_messageOrderedFields.end())
502  throw ConfigError("<Message> " + msgType + " does not have a stored message order");
503 
504  return iter->second.getMessageOrder();
505 }

◆ getOrderedFields()

message_order const & FIX::DataDictionary::getOrderedFields ( ) const

Definition at line 441 of file DataDictionary.cpp.

442 {
444 
445  int * tmp = new int[m_orderedFields.size() + 1];
446  int * i = tmp;
447 
448  OrderedFields::const_iterator iter;
449  for( iter = m_orderedFields.begin(); iter != m_orderedFields.end(); *(i++) = *(iter++) ) {}
450  *i = 0;
451 
452  m_orderedFieldsArray = message_order(tmp);
453  delete [] tmp;
454 
455  return m_orderedFieldsArray;
456 }

References m_orderedFields, and m_orderedFieldsArray.

◆ getTrailerOrderedFields()

message_order const & FIX::DataDictionary::getTrailerOrderedFields ( ) const
throw (ConfigError
)

Definition at line 478 of file DataDictionary.cpp.

479 {
480  if( m_trailerOrder ) return m_trailerOrder;
481 
482  if (m_trailerOrderedFields.size() == 0)
483  throw ConfigError("<Trailer> does not have a stored message order");
484 
485  int * tmp = new int[m_trailerOrderedFields.size() + 1];
486  int * i = tmp;
487 
488  OrderedFields::const_iterator iter;
489  for( iter = m_trailerOrderedFields.begin(); iter != m_trailerOrderedFields.end(); *(i++) = *(iter++) ) {}
490  *i = 0;
491 
492  m_trailerOrder = message_order(tmp);
493  delete [] tmp;
494 
495  return m_trailerOrder;
496 }

References m_trailerOrder, and m_trailerOrderedFields.

◆ getValueName()

bool FIX::DataDictionary::getValueName ( int  field,
const std::string &  value,
std::string &  name 
) const
inline

Definition at line 190 of file DataDictionary.h.

192  {
193  return m_messages.find( msgType ) != m_messages.end();
194  }
195 
196  void addMsgField( const std::string& msgType, int field )

References m_messages.

◆ getVersion()

std::string FIX::DataDictionary::getVersion ( ) const
inline

Definition at line 151 of file DataDictionary.h.

153  {
154  FieldToName::const_iterator i = m_fieldNames.find( field );

References m_fieldNames.

◆ hasFieldValue()

bool FIX::DataDictionary::hasFieldValue ( int  field) const
inline

Definition at line 293 of file DataDictionary.h.

294  {
295  endPos = value.find_first_of(' ', startPos);
296  std::string singleValue =
297  value.substr( startPos, endPos - startPos );

◆ isDataField()

bool FIX::DataDictionary::isDataField ( int  field) const
inline

Definition at line 360 of file DataDictionary.h.

361  { m_checkFieldsHaveValues = value; }
362  void checkUserDefinedFields( bool value )
363  { m_checkUserDefinedFields = value; }
364  void allowUnknownMsgFields( bool value )

References m_checkFieldsHaveValues.

◆ isField()

bool FIX::DataDictionary::isField ( int  field) const
inline

Definition at line 198 of file DataDictionary.h.

199  {
200  m_messageOrderedFields[ msgType ].push_back(field);
201  }

References m_messageOrderedFields.

◆ isFieldValue()

bool FIX::DataDictionary::isFieldValue ( int  field,
const std::string &  value 
) const
inline

Definition at line 299 of file DataDictionary.h.

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;

◆ isGroup()

bool FIX::DataDictionary::isGroup ( const std::string &  msg,
int  field 
) const
inline

Definition at line 332 of file DataDictionary.h.

344  {

Referenced by checkHasValue().

◆ isHeaderField()

bool FIX::DataDictionary::isHeaderField ( int  field) const
inline

Definition at line 240 of file DataDictionary.h.

244  {

◆ isMessageFieldsOrderPreserved()

bool FIX::DataDictionary::isMessageFieldsOrderPreserved ( ) const
inline

Definition at line 385 of file DataDictionary.h.

389  {

◆ isMsgField()

bool FIX::DataDictionary::isMsgField ( const std::string &  msgType,
int  field 
) const
inline

Definition at line 223 of file DataDictionary.h.

224  {
225  return m_headerFields.find( field ) != m_headerFields.end();
226  }
227 
228  void addTrailerField( int field, bool required )

References m_headerFields.

Referenced by checkValue().

◆ isMsgType()

bool FIX::DataDictionary::isMsgType ( const std::string &  msgType) const
inline

Definition at line 208 of file DataDictionary.h.

214  {

◆ isMultipleValueField()

bool FIX::DataDictionary::isMultipleValueField ( int  field) const
inline

Definition at line 366 of file DataDictionary.h.

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,

References m_storeMsgFieldsOrder.

Referenced by isRequiredField().

◆ isRequiredField()

bool FIX::DataDictionary::isRequiredField ( const std::string &  msgType,
int  field 
) const
inline

Definition at line 281 of file DataDictionary.h.

283  {
284  FieldToValue::const_iterator i = m_fieldValues.find( field );
285  if ( i == m_fieldValues.end() )
286  return false;

References isMultipleValueField(), and m_fieldValues.

◆ isTrailerField()

bool FIX::DataDictionary::isTrailerField ( int  field) const
inline

Definition at line 255 of file DataDictionary.h.

◆ iterate()

void FIX::DataDictionary::iterate ( const FieldMap map,
const MsgType &  msgType 
) const
private

Iterate through fields while applying checks.

Definition at line 173 of file DataDictionary.cpp.

174 {
175  int lastField = 0;
176 
178  for ( i = map.begin(); i != map.end(); ++i )
179  {
180  const FieldBase& field = (*i);
181  if( i != map.begin() && (field.getTag() == lastField) )
182  throw RepeatedTag( lastField );
183  checkHasValue( field );
184 
185  if ( m_hasVersion )
186  {
187  checkValidFormat( field );
188  checkValue( field );
189  }
190 
191  if ( m_beginString.getValue().length() && shouldCheckTag(field) )
192  {
193  checkValidTagNumber( field );
194  if ( !Message::isHeaderField( field, this )
195  && !Message::isTrailerField( field, this ) )
196  {
197  checkIsInMessage( field, msgType );
198  checkGroupCount( field, map, msgType );
199  }
200  }
201  lastField = field.getTag();
202  }
203 }

References FIX::FieldMap::begin(), checkGroupCount(), checkHasValue(), checkIsInMessage(), checkValidFormat(), checkValidTagNumber(), checkValue(), FIX::FieldMap::end(), FIX::FieldBase::getTag(), FIX::Message::isHeaderField(), FIX::Message::isTrailerField(), m_beginString, m_hasVersion, and shouldCheckTag().

◆ lookupXMLFieldNumber() [1/2]

int FIX::DataDictionary::lookupXMLFieldNumber ( DOMDocument pDoc,
const std::string &  name 
) const
private

Definition at line 517 of file DataDictionary.cpp.

518 {
519  NameToField::const_iterator i = m_names.find(name);
520  if( i == m_names.end() )
521  throw ConfigError("Field " + name + " not defined in fields section");
522  return i->second;
523 }

◆ lookupXMLFieldNumber() [2/2]

int FIX::DataDictionary::lookupXMLFieldNumber ( DOMDocument pDoc,
DOMNode pNode 
) const
private

Definition at line 507 of file DataDictionary.cpp.

508 {
509  DOMAttributesPtr attrs = pNode->getAttributes();
510  std::string name;
511  if(!attrs->get("name", name))
512  throw ConfigError("No name given to field");
513  return lookupXMLFieldNumber( pDoc, name );
514 }

References FIX::DOMNode::getAttributes().

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ operator=()

DataDictionary & FIX::DataDictionary::operator= ( const DataDictionary rhs)

Definition at line 80 of file DataDictionary.cpp.

81 {
82  m_hasVersion = rhs.m_hasVersion;
83  m_checkFieldsOutOfOrder = rhs.m_checkFieldsOutOfOrder;
84  m_checkFieldsHaveValues = rhs.m_checkFieldsHaveValues;
85  m_storeMsgFieldsOrder = rhs.m_storeMsgFieldsOrder;
86  m_checkUserDefinedFields = rhs.m_checkUserDefinedFields;
87  m_allowUnknownMessageFields = rhs.m_allowUnknownMessageFields;
88  m_beginString = rhs.m_beginString;
89  m_messageFields = rhs.m_messageFields;
90  m_requiredFields = rhs.m_requiredFields;
91  m_messages = rhs.m_messages;
92  m_fields = rhs.m_fields;
93  m_orderedFields = rhs.m_orderedFields;
94  m_orderedFieldsArray = rhs.m_orderedFieldsArray;
95  m_headerFields = rhs.m_headerFields;
96  m_trailerFields = rhs.m_trailerFields;
97  m_fieldTypes = rhs.m_fieldTypes;
98  m_fieldValues = rhs.m_fieldValues;
99  m_fieldNames = rhs.m_fieldNames;
100  m_names = rhs.m_names;
101  m_valueNames = rhs.m_valueNames;
102  m_dataFields = rhs.m_dataFields;
103  m_headerOrderedFields = rhs.m_headerOrderedFields;
104  m_headerOrder = rhs.m_headerOrder;
105  m_trailerOrderedFields = rhs.m_trailerOrderedFields;
106  m_trailerOrder = rhs.m_trailerOrder;
107  m_messageOrderedFields = rhs.m_messageOrderedFields;
108 
109  FieldToGroup::const_iterator i = rhs.m_groups.begin();
110  for ( ; i != rhs.m_groups.end(); ++i )
111  {
112  const FieldPresenceMap& presenceMap = i->second;
113 
114  FieldPresenceMap::const_iterator iter = presenceMap.begin();
115  for ( ; iter != presenceMap.end(); ++iter )
116  {
117  addGroup( iter->first, i->first, iter->second.first, *iter->second.second );
118  }
119  }
120  return *this;
121 }

References addGroup(), m_allowUnknownMessageFields, m_beginString, m_checkFieldsHaveValues, m_checkFieldsOutOfOrder, m_checkUserDefinedFields, m_dataFields, m_fieldNames, m_fields, m_fieldTypes, m_fieldValues, m_groups, m_hasVersion, m_headerFields, m_headerOrder, m_headerOrderedFields, m_messageFields, m_messageOrderedFields, m_messages, m_names, m_orderedFields, m_orderedFieldsArray, m_requiredFields, m_storeMsgFieldsOrder, m_trailerFields, m_trailerOrder, m_trailerOrderedFields, and m_valueNames.

◆ preserveMessageFieldsOrder()

void FIX::DataDictionary::preserveMessageFieldsOrder ( bool  value)
inline

Definition at line 383 of file DataDictionary.h.

383  :

◆ readFromDocument()

void FIX::DataDictionary::readFromDocument ( const DOMDocumentPtr pDoc)
throw (ConfigError
)

Definition at line 234 of file DataDictionary.cpp.

236 {
237  // VERSION
238  DOMNodePtr pFixNode = pDoc->getNode("/fix");
239  if(!pFixNode.get())
240  throw ConfigError("Could not parse data dictionary file"
241  ", or no <fix> node found at root");
242  DOMAttributesPtr attrs = pFixNode->getAttributes();
243  std::string type = "FIX";
244  if(attrs->get("type", type))
245  {
246  if(type != "FIX" && type != "FIXT")
247  throw ConfigError("type attribute must be FIX or FIXT");
248  }
249  std::string major;
250  if(!attrs->get("major", major))
251  throw ConfigError("major attribute not found on <fix>");
252  std::string minor;
253  if(!attrs->get("minor", minor))
254  throw ConfigError("minor attribute not found on <fix>");
255  setVersion(type + "." + major + "." + minor);
256 
257  // FIELDS
258  DOMNodePtr pFieldsNode = pDoc->getNode("/fix/fields");
259  if(!pFieldsNode.get())
260  throw ConfigError("<fields> section not found in data dictionary");
261 
262  DOMNodePtr pFieldNode = pFieldsNode->getFirstChildNode();
263  if(!pFieldNode.get()) throw ConfigError("No fields defined");
264 
265  while(pFieldNode.get())
266  {
267  if(pFieldNode->getName() == "field")
268  {
269  DOMAttributesPtr attrs = pFieldNode->getAttributes();
270  std::string name;
271  if(!attrs->get("name", name))
272  throw ConfigError("<field> does not have a name attribute");
273  std::string number;
274  if(!attrs->get("number", number))
275  throw ConfigError("<field> " + name + " does not have a number attribute");
276  int num = atoi(number.c_str());
277  std::string type;
278  if(!attrs->get("type", type))
279  throw ConfigError("<field> " + name + " does not have a type attribute");
280  addField(num);
281  addFieldType(num, XMLTypeToType(type));
282  addFieldName(num, name);
283 
284  DOMNodePtr pFieldValueNode = pFieldNode->getFirstChildNode();
285  while(pFieldValueNode.get())
286  {
287  if(pFieldValueNode->getName() == "value")
288  {
289  DOMAttributesPtr attrs = pFieldValueNode->getAttributes();
290  std::string enumeration;
291  if(!attrs->get("enum", enumeration))
292  throw ConfigError("<value> does not have enum attribute in field " + name);
293  addFieldValue(num, enumeration);
294  std::string description;
295  if(attrs->get("description", description))
296  addValueName(num, enumeration, description);
297  }
298  RESET_AUTO_PTR(pFieldValueNode, pFieldValueNode->getNextSiblingNode());
299  }
300  }
301  RESET_AUTO_PTR(pFieldNode, pFieldNode->getNextSiblingNode());
302  }
303 
304  // HEADER
305  if( type == "FIXT" || (type == "FIX" && major < "5") )
306  {
307  DOMNodePtr pHeaderNode = pDoc->getNode("/fix/header");
308  if(!pHeaderNode.get())
309  throw ConfigError("<header> section not found in data dictionary");
310 
311  DOMNodePtr pHeaderFieldNode = pHeaderNode->getFirstChildNode();
312  if(!pHeaderFieldNode.get()) throw ConfigError("No header fields defined");
313 
314  while(pHeaderFieldNode.get())
315  {
316  if(pHeaderFieldNode->getName() == "field" || pHeaderFieldNode->getName() == "group" )
317  {
318  DOMAttributesPtr attrs = pHeaderFieldNode->getAttributes();
319  std::string name;
320  if(!attrs->get("name", name))
321  throw ConfigError("<field> does not have a name attribute");
322  std::string required = "false";
323  attrs->get("required", required);
324  addHeaderField(lookupXMLFieldNumber(pDoc.get(), name), required == "true");
325  }
326  if(pHeaderFieldNode->getName() == "group")
327  {
328  DOMAttributesPtr attrs = pHeaderFieldNode->getAttributes();
329  std::string required;
330  attrs->get("required", required);
331  bool isRequired = (required == "Y" || required == "y");
332  addXMLGroup(pDoc.get(), pHeaderFieldNode.get(), "_header_", *this, isRequired);
333  }
334 
335  RESET_AUTO_PTR(pHeaderFieldNode, pHeaderFieldNode->getNextSiblingNode());
336  }
337  }
338 
339  // TRAILER
340  if( type == "FIXT" || (type == "FIX" && major < "5") )
341  {
342  DOMNodePtr pTrailerNode = pDoc->getNode("/fix/trailer");
343  if(!pTrailerNode.get())
344  throw ConfigError("<trailer> section not found in data dictionary");
345 
346  DOMNodePtr pTrailerFieldNode = pTrailerNode->getFirstChildNode();
347  if(!pTrailerFieldNode.get()) throw ConfigError("No trailer fields defined");
348 
349  while(pTrailerFieldNode.get())
350  {
351  if(pTrailerFieldNode->getName() == "field" || pTrailerFieldNode->getName() == "group" )
352  {
353  DOMAttributesPtr attrs = pTrailerFieldNode->getAttributes();
354  std::string name;
355  if(!attrs->get("name", name))
356  throw ConfigError("<field> does not have a name attribute");
357  std::string required = "false";
358  attrs->get("required", required);
359  addTrailerField(lookupXMLFieldNumber(pDoc.get(), name), required == "true");
360  }
361  if(pTrailerFieldNode->getName() == "group")
362  {
363  DOMAttributesPtr attrs = pTrailerFieldNode->getAttributes();
364  std::string required;
365  attrs->get("required", required);
366  bool isRequired = (required == "Y" || required == "y");
367  addXMLGroup(pDoc.get(), pTrailerFieldNode.get(), "_trailer_", *this, isRequired);
368  }
369 
370  RESET_AUTO_PTR(pTrailerFieldNode, pTrailerFieldNode->getNextSiblingNode());
371  }
372  }
373 
374  // MSGTYPE
375  DOMNodePtr pMessagesNode = pDoc->getNode("/fix/messages");
376  if(!pMessagesNode.get())
377  throw ConfigError("<messages> section not found in data dictionary");
378 
379  DOMNodePtr pMessageNode = pMessagesNode->getFirstChildNode();
380  if(!pMessageNode.get()) throw ConfigError("No messages defined");
381 
382  while(pMessageNode.get())
383  {
384  if(pMessageNode->getName() == "message")
385  {
386  DOMAttributesPtr attrs = pMessageNode->getAttributes();
387  std::string msgtype;
388  if(!attrs->get("msgtype", msgtype))
389  throw ConfigError("<field> does not have a name attribute");
390  addMsgType(msgtype);
391 
392  std::string name;
393  if(attrs->get("name", name))
394  addValueName( 35, msgtype, name );
395 
396  DOMNodePtr pMessageFieldNode = pMessageNode->getFirstChildNode();
397  while( pMessageFieldNode.get() )
398  {
399  if(pMessageFieldNode->getName() == "field"
400  || pMessageFieldNode->getName() == "group")
401  {
402  DOMAttributesPtr attrs = pMessageFieldNode->getAttributes();
403  std::string name;
404  if(!attrs->get("name", name))
405  throw ConfigError("<field> does not have a name attribute");
406  int num = lookupXMLFieldNumber(pDoc.get(), name);
407  addMsgField(msgtype, num);
408 
409  std::string required;
410  if(attrs->get("required", required)
411  && (required == "Y" || required == "y"))
412  {
413  addRequiredField(msgtype, num);
414  }
415  }
416  else if(pMessageFieldNode->getName() == "component")
417  {
418  DOMAttributesPtr attrs = pMessageFieldNode->getAttributes();
419  std::string required;
420  attrs->get("required", required);
421  bool isRequired = (required == "Y" || required == "y");
422  addXMLComponentFields(pDoc.get(), pMessageFieldNode.get(),
423  msgtype, *this, isRequired);
424  }
425  if(pMessageFieldNode->getName() == "group")
426  {
427  DOMAttributesPtr attrs = pMessageFieldNode->getAttributes();
428  std::string required;
429  attrs->get("required", required);
430  bool isRequired = (required == "Y" || required == "y");
431  addXMLGroup(pDoc.get(), pMessageFieldNode.get(), msgtype, *this, isRequired);
432  }
433  RESET_AUTO_PTR(pMessageFieldNode,
434  pMessageFieldNode->getNextSiblingNode());
435  }
436  }
437  RESET_AUTO_PTR(pMessageNode, pMessageNode->getNextSiblingNode());
438  }
439 }

References RESET_AUTO_PTR.

◆ readFromStream()

void FIX::DataDictionary::readFromStream ( std::istream &  stream)
throw (ConfigError
)

Definition at line 223 of file DataDictionary.cpp.

225 {
226  DOMDocumentPtr pDoc(new PUGIXML_DOMDocument());
227 
228  if(!pDoc->load(stream))
229  throw ConfigError("Could not parse data dictionary stream");
230 
231  readFromDocument( pDoc );
232 }

◆ readFromURL()

void FIX::DataDictionary::readFromURL ( const std::string &  url)
throw (ConfigError
)

Definition at line 205 of file DataDictionary.cpp.

207 {
208  DOMDocumentPtr pDoc(new PUGIXML_DOMDocument());
209 
210  if(!pDoc->load(url))
211  throw ConfigError(url + ": Could not parse data dictionary file");
212 
213  try
214  {
215  readFromDocument( pDoc );
216  }
217  catch( ConfigError& e )
218  {
219  throw ConfigError( url + ": " + e.what() );
220  }
221 }

◆ setVersion()

void FIX::DataDictionary::setVersion ( const std::string &  beginString)
inline

Definition at line 146 of file DataDictionary.h.

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  }

References m_fieldNames, and m_names.

◆ shouldCheckTag()

bool FIX::DataDictionary::shouldCheckTag ( const FieldBase field) const
inlineprivate

If we need to check for the tag in the dictionary.

Definition at line 412 of file DataDictionary.h.

415  {
416  try
417  {
418  TYPE::Type type = TYPE::Unknown;
419  getFieldType( field.getTag(), type );
420  switch ( type )

References getFieldType(), FIX::TYPE::String, and FIX::TYPE::Unknown.

Referenced by iterate().

◆ validate() [1/3]

void FIX::DataDictionary::validate ( const Message message) const
throw (FIX::Exception
)
inline

Definition at line 393 of file DataDictionary.h.

396  {

◆ validate() [2/3]

void FIX::DataDictionary::validate ( const Message message,
bool  bodyOnly 
) const
throw (FIX::Exception
)
inline

◆ validate() [3/3]

void FIX::DataDictionary::validate ( const Message message,
const DataDictionary *const  pSessionDD,
const DataDictionary *const  pAppID 
)
throw (FIX::Exception
)
static

Validate a message.

Definition at line 123 of file DataDictionary.cpp.

127 {
128  const Header& header = message.getHeader();
129  const BeginString& beginString = FIELD_GET_REF( header, BeginString );
130 #ifdef HAVE_EMX
131  const std::string & msgType = message.getSubMessageType();
132  if (msgType.empty())
133  {
134  throw InvalidMessageType("empty subMsgType, check Tag 9426/MESSAGE_ID");
135  }
136 #else
137  const MsgType& msgType = FIELD_GET_REF( header, MsgType );
138 #endif
139  if ( pSessionDD != 0 && pSessionDD->m_hasVersion )
140  {
141  if( pSessionDD->getVersion() != beginString )
142  {
143  throw UnsupportedVersion();
144  }
145  }
146 
147  int field = 0;
148  if( (pSessionDD !=0 && pSessionDD->m_checkFieldsOutOfOrder) ||
149  (pAppDD != 0 && pAppDD->m_checkFieldsOutOfOrder) )
150  {
151  if ( !message.hasValidStructure(field) )
152  throw TagOutOfOrder(field);
153  }
154 
155  if ( pAppDD != 0 && pAppDD->m_hasVersion )
156  {
157  pAppDD->checkMsgType( msgType );
158  pAppDD->checkHasRequired( message.getHeader(), message, message.getTrailer(), msgType );
159  }
160 
161  if( pSessionDD != 0 )
162  {
163  pSessionDD->iterate( message.getHeader(), msgType );
164  pSessionDD->iterate( message.getTrailer(), msgType );
165  }
166 
167  if( pAppDD != 0 )
168  {
169  pAppDD->iterate( message, msgType );
170  }
171 }

References FIELD_GET_REF.

Referenced by checkFieldsHaveValues(), and checkUserDefinedFields().

◆ XMLTypeToType()

TYPE::Type FIX::DataDictionary::XMLTypeToType ( const std::string &  xmlType) const
private

Definition at line 646 of file DataDictionary.cpp.

647 {
648  if ( m_beginString < "FIX.4.2" && type == "CHAR" )
649  return TYPE::String;
650 
651  if ( type == "STRING" ) return TYPE::String;
652  if ( type == "CHAR" ) return TYPE::Char;
653  if ( type == "PRICE" ) return TYPE::Price;
654  if ( type == "INT" ) return TYPE::Int;
655  if ( type == "AMT" ) return TYPE::Amt;
656  if ( type == "QTY" ) return TYPE::Qty;
657  if ( type == "CURRENCY" ) return TYPE::Currency;
658  if ( type == "MULTIPLEVALUESTRING" ) return TYPE::MultipleValueString;
659  if ( type == "MULTIPLESTRINGVALUE" ) return TYPE::MultipleStringValue;
660  if ( type == "MULTIPLECHARVALUE" ) return TYPE::MultipleCharValue;
661  if ( type == "EXCHANGE" ) return TYPE::Exchange;
662  if ( type == "UTCTIMESTAMP" ) return TYPE::UtcTimeStamp;
663  if ( type == "BOOLEAN" ) return TYPE::Boolean;
664  if ( type == "LOCALMKTDATE" ) return TYPE::LocalMktDate;
665  if ( type == "DATA" ) return TYPE::Data;
666  if ( type == "FLOAT" ) return TYPE::Float;
667  if ( type == "PRICEOFFSET" ) return TYPE::PriceOffset;
668  if ( type == "MONTHYEAR" ) return TYPE::MonthYear;
669  if ( type == "DAYOFMONTH" ) return TYPE::DayOfMonth;
670  if ( type == "UTCDATE" ) return TYPE::UtcDate;
671  if ( type == "UTCDATEONLY" ) return TYPE::UtcDateOnly;
672  if ( type == "UTCTIMEONLY" ) return TYPE::UtcTimeOnly;
673  if ( type == "NUMINGROUP" ) return TYPE::NumInGroup;
674  if ( type == "PERCENTAGE" ) return TYPE::Percentage;
675  if ( type == "SEQNUM" ) return TYPE::SeqNum;
676  if ( type == "LENGTH" ) return TYPE::Length;
677  if ( type == "COUNTRY" ) return TYPE::Country;
678  if ( type == "TIME" ) return TYPE::UtcTimeStamp;
679  return TYPE::Unknown;
680 }

References FIX::TYPE::Amt, FIX::TYPE::Boolean, FIX::TYPE::Char, FIX::TYPE::Country, FIX::TYPE::Currency, FIX::TYPE::Data, FIX::TYPE::DayOfMonth, FIX::TYPE::Exchange, FIX::TYPE::Float, FIX::TYPE::Int, FIX::TYPE::Length, FIX::TYPE::LocalMktDate, m_beginString, FIX::TYPE::MonthYear, FIX::TYPE::MultipleCharValue, FIX::TYPE::MultipleStringValue, FIX::TYPE::MultipleValueString, FIX::TYPE::NumInGroup, FIX::TYPE::Percentage, FIX::TYPE::Price, FIX::TYPE::PriceOffset, FIX::TYPE::Qty, FIX::TYPE::SeqNum, FIX::TYPE::String, FIX::TYPE::Unknown, FIX::TYPE::UtcDate, FIX::TYPE::UtcDateOnly, FIX::TYPE::UtcTimeOnly, and FIX::TYPE::UtcTimeStamp.

Member Data Documentation

◆ m_allowUnknownMessageFields

bool FIX::DataDictionary::m_allowUnknownMessageFields
private

Definition at line 603 of file DataDictionary.h.

Referenced by operator=(), and validate().

◆ m_beginString

BeginString FIX::DataDictionary::m_beginString
private

Definition at line 606 of file DataDictionary.h.

Referenced by iterate(), operator=(), and XMLTypeToType().

◆ m_checkFieldsHaveValues

bool FIX::DataDictionary::m_checkFieldsHaveValues
private

Definition at line 601 of file DataDictionary.h.

Referenced by isDataField(), and operator=().

◆ m_checkFieldsOutOfOrder

bool FIX::DataDictionary::m_checkFieldsOutOfOrder
private

Definition at line 600 of file DataDictionary.h.

Referenced by operator=().

◆ m_checkUserDefinedFields

bool FIX::DataDictionary::m_checkUserDefinedFields
private

Definition at line 602 of file DataDictionary.h.

Referenced by operator=(), and validate().

◆ m_dataFields

MsgFields FIX::DataDictionary::m_dataFields
private

Definition at line 621 of file DataDictionary.h.

Referenced by getGroup(), and operator=().

◆ m_fieldNames

FieldToName FIX::DataDictionary::m_fieldNames
private

Definition at line 617 of file DataDictionary.h.

Referenced by getVersion(), operator=(), and setVersion().

◆ m_fields

Fields FIX::DataDictionary::m_fields
private

Definition at line 610 of file DataDictionary.h.

Referenced by operator=().

◆ m_fieldTypes

FieldTypes FIX::DataDictionary::m_fieldTypes
private

Definition at line 615 of file DataDictionary.h.

Referenced by operator=().

◆ m_fieldValues

FieldToValue FIX::DataDictionary::m_fieldValues
private

Definition at line 616 of file DataDictionary.h.

Referenced by addRequiredField(), isRequiredField(), and operator=().

◆ m_groups

FieldToGroup FIX::DataDictionary::m_groups
private

Definition at line 620 of file DataDictionary.h.

Referenced by operator=(), and ~DataDictionary().

◆ m_hasVersion

bool FIX::DataDictionary::m_hasVersion
private

Definition at line 599 of file DataDictionary.h.

Referenced by iterate(), and operator=().

◆ m_headerFields

NonBodyFields FIX::DataDictionary::m_headerFields
private

Definition at line 613 of file DataDictionary.h.

Referenced by addMsgField(), checkGroupCount(), isMsgField(), and operator=().

◆ m_headerOrder

OrderedFieldsArray FIX::DataDictionary::m_headerOrder
mutableprivate

Definition at line 623 of file DataDictionary.h.

Referenced by getHeaderOrderedFields(), and operator=().

◆ m_headerOrderedFields

OrderedFields FIX::DataDictionary::m_headerOrderedFields
private

Definition at line 622 of file DataDictionary.h.

Referenced by addMsgField(), getHeaderOrderedFields(), and operator=().

◆ m_messageFields

MsgTypeToField FIX::DataDictionary::m_messageFields
private

Definition at line 607 of file DataDictionary.h.

Referenced by operator=().

◆ m_messageOrderedFields

MsgTypeToOrderedFields FIX::DataDictionary::m_messageOrderedFields
private

Definition at line 626 of file DataDictionary.h.

Referenced by isField(), and operator=().

◆ m_messages

MsgTypes FIX::DataDictionary::m_messages
private

Definition at line 609 of file DataDictionary.h.

Referenced by addValueName(), getValueName(), and operator=().

◆ m_names

NameToField FIX::DataDictionary::m_names
private

Definition at line 618 of file DataDictionary.h.

Referenced by operator=(), and setVersion().

◆ m_orderedFields

OrderedFields FIX::DataDictionary::m_orderedFields
private

Definition at line 611 of file DataDictionary.h.

Referenced by getOrderedFields(), and operator=().

◆ m_orderedFieldsArray

OrderedFieldsArray FIX::DataDictionary::m_orderedFieldsArray
mutableprivate

Definition at line 612 of file DataDictionary.h.

Referenced by getOrderedFields(), and operator=().

◆ m_requiredFields

MsgTypeToField FIX::DataDictionary::m_requiredFields
private

Definition at line 608 of file DataDictionary.h.

Referenced by addFieldType(), and operator=().

◆ m_storeMsgFieldsOrder

bool FIX::DataDictionary::m_storeMsgFieldsOrder
private

Definition at line 604 of file DataDictionary.h.

Referenced by addMsgField(), isMultipleValueField(), and operator=().

◆ m_trailerFields

NonBodyFields FIX::DataDictionary::m_trailerFields
private

Definition at line 614 of file DataDictionary.h.

Referenced by checkGroupCount(), and operator=().

◆ m_trailerOrder

OrderedFieldsArray FIX::DataDictionary::m_trailerOrder
mutableprivate

Definition at line 625 of file DataDictionary.h.

Referenced by getTrailerOrderedFields(), and operator=().

◆ m_trailerOrderedFields

OrderedFields FIX::DataDictionary::m_trailerOrderedFields
private

Definition at line 624 of file DataDictionary.h.

Referenced by addHeaderField(), getTrailerOrderedFields(), and operator=().

◆ m_valueNames

ValueToName FIX::DataDictionary::m_valueNames
private

Definition at line 619 of file DataDictionary.h.

Referenced by getFieldName(), and operator=().


The documentation for this class was generated from the following files:
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::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
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::readFromDocument
void readFromDocument(const DOMDocumentPtr &pDoc)
Definition: DataDictionary.cpp:234
FIX::DOMAttributesPtr
SmartPtr< DOMAttributes > DOMAttributesPtr
Definition: DOMDocument.h:45
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::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::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::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::m_trailerOrderedFields
OrderedFields m_trailerOrderedFields
Definition: DataDictionary.h:624
FIX::DataDictionary::checkUserDefinedFields
void checkUserDefinedFields(bool value)
Definition: DataDictionary.h:379
FIX::TYPE::MultipleValueString
@ MultipleValueString
Definition: FieldTypes.h:936
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
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::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::readFromURL
void readFromURL(const std::string &url)
Definition: DataDictionary.cpp:205
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::Message::isTrailerField
static bool isTrailerField(int field)
Definition: Message.cpp:567
FIX::IntConvertor::convert
static std::string convert(signed_int value)
Definition: FieldConvertors.h:170
FIX::DOMNodePtr
SmartPtr< DOMNode > DOMNodePtr
Definition: DOMDocument.h:59
RESET_AUTO_PTR
#define RESET_AUTO_PTR(OLD, NEW)
Definition: DataDictionary.cpp:36
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::m_valueNames
ValueToName m_valueNames
Definition: DataDictionary.h:619
FIX::DataDictionary::m_messageFields
MsgTypeToField m_messageFields
Definition: DataDictionary.h:607
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::DataDictionary::lookupXMLFieldNumber
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const
Definition: DataDictionary.cpp:507
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::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::TYPE::Data
@ Data
Definition: FieldTypes.h:943
FIX::BoolConvertor::convert
static std::string convert(bool value)
Definition: FieldConvertors.h:418
FIX::TYPE::Exchange
@ Exchange
Definition: FieldTypes.h:939
FIX::DataDictionary::isGroup
bool isGroup(const std::string &msg, int field) const
Definition: DataDictionary.h:332
FIX::DataDictionary::addFieldType
void addFieldType(int field, FIX::TYPE::Type type)
Definition: DataDictionary.h:260
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::Message::isHeaderField
static bool isHeaderField(int field)
Definition: Message.cpp:514
FIX::TYPE::TzTimeOnly
@ TzTimeOnly
Definition: FieldTypes.h:956
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::DataDictionary::getVersion
std::string getVersion() const
Definition: DataDictionary.h:151
FIX::DataDictionary::m_checkUserDefinedFields
bool m_checkUserDefinedFields
Definition: DataDictionary.h:602
FIX::DataDictionary::m_requiredFields
MsgTypeToField m_requiredFields
Definition: DataDictionary.h:608
FIX::TYPE::Unknown
@ Unknown
Definition: FieldTypes.h:928
FIX::TYPE::Qty
@ Qty
Definition: FieldTypes.h:934
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::addGroup
void addGroup(const std::string &msg, int field, int delim, const DataDictionary &dataDictionary)
Definition: DataDictionary.h:322
FIX::DataDictionary::m_headerFields
NonBodyFields m_headerFields
Definition: DataDictionary.h:613
FIX::TYPE::UtcDateOnly
@ UtcDateOnly
Definition: FieldTypes.h:949
FIELD_GET_REF
#define FIELD_GET_REF(MAP, FLD)
Definition: FieldMap.h:376
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::getFieldType
bool getFieldType(int field, FIX::TYPE::Type &type) const
Definition: DataDictionary.h:268
FIX::TYPE::Type
Type
Definition: FieldTypes.h:926
FIX::UtcTimeOnlyConvertor::convert
static std::string convert(const UtcTimeOnly &value, int precision=0)
Definition: FieldConvertors.h:565
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::FieldMap::const_iterator
Fields::const_iterator const_iterator
Definition: FieldMap.h:134
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