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 64 of file DataDictionary.h.

Member Typedef Documentation

◆ FieldPresenceMap

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

Definition at line 124 of file DataDictionary.h.

◆ Fields

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

Definition at line 69 of file DataDictionary.h.

◆ FieldToGroup

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

Definition at line 125 of file DataDictionary.h.

◆ FieldToName

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

Definition at line 116 of file DataDictionary.h.

◆ FieldToValue

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

Definition at line 115 of file DataDictionary.h.

◆ FieldTypes

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

Definition at line 113 of file DataDictionary.h.

◆ MsgFields

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

Definition at line 66 of file DataDictionary.h.

◆ MsgTypes

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

Definition at line 68 of file DataDictionary.h.

◆ MsgTypeToField

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

Definition at line 67 of file DataDictionary.h.

◆ MsgTypeToOrderedFields

Definition at line 110 of file DataDictionary.h.

◆ NameToField

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

Definition at line 117 of file DataDictionary.h.

◆ NonBodyFields

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

Definition at line 70 of file DataDictionary.h.

◆ OrderedFields

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

Definition at line 71 of file DataDictionary.h.

◆ OrderedFieldsArray

Definition at line 112 of file DataDictionary.h.

◆ Values

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

Definition at line 114 of file DataDictionary.h.

◆ ValueToName

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

Definition at line 118 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 154 of file DataDictionary.h.

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ addFieldName()

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

Definition at line 160 of file DataDictionary.h.

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;

References m_names.

◆ addFieldType()

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

Definition at line 258 of file DataDictionary.h.

260  {
261  m_requiredFields[ msgType ].insert( field );
262  }
263 
264  bool isRequiredField( const std::string& msgType, int field ) const

References m_requiredFields.

◆ addFieldValue()

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

Definition at line 286 of file DataDictionary.h.

◆ addGroup()

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

Definition at line 320 of file DataDictionary.h.

328  {

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

◆ addHeaderField()

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

Definition at line 228 of file DataDictionary.h.

229  {
231  {
232  m_trailerOrderedFields.push_back(field);
233  }
234 
235  m_trailerFields[ field ] = required;
236  }

References m_storeMsgFieldsOrder, m_trailerFields, and m_trailerOrderedFields.

◆ addMsgField()

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

Definition at line 211 of file DataDictionary.h.

214  {
216  {
217  m_headerOrderedFields.push_back(field);
218  }
219 

Referenced by addXMLComponentFields().

◆ addMsgType()

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

Definition at line 201 of file DataDictionary.h.

◆ addRequiredField()

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

Definition at line 274 of file DataDictionary.h.

277  {

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ addTrailerField()

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

Definition at line 243 of file DataDictionary.h.

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

References FIX::TYPE::Data, m_dataFields, and m_fieldTypes.

◆ addValueName()

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

Definition at line 183 of file DataDictionary.h.

187  {

◆ 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 379 of file DataDictionary.h.

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

References validate().

◆ checkFieldsHaveValues()

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

Definition at line 375 of file DataDictionary.h.

377  { validate( message, false ); }

◆ checkFieldsOutOfOrder()

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

Definition at line 373 of file DataDictionary.h.

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

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 547 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 515 of file DataDictionary.h.

520  {

References 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 524 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 403 of file DataDictionary.h.

408  {

◆ checkUserDefinedFields()

void FIX::DataDictionary::checkUserDefinedFields ( 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().

◆ checkValidFormat()

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

Definition at line 428 of file DataDictionary.h.

428  :
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  {

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 421 of file DataDictionary.h.

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:

References FIX::TYPE::Char, FIX::EmptyConvertor::convert(), FIX::DoubleConvertor::convert(), FIX::CharConvertor::convert(), FIX::TYPE::Price, and FIX::TYPE::String.

Referenced by iterate().

◆ checkValue()

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

Definition at line 504 of file DataDictionary.h.

511  {
512  if ( !isMsgField( msgType, field.getTag() ) )

Referenced by iterate().

◆ getFieldName()

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

Definition at line 167 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

References m_valueNames.

◆ getFieldTag()

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

Definition at line 175 of file DataDictionary.h.

182  {

◆ getFieldType()

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

Definition at line 266 of file DataDictionary.h.

272  {

◆ getGroup()

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

Definition at line 341 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  }

◆ 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 188 of file DataDictionary.h.

192  {
193  return m_messages.find( msgType ) != m_messages.end();
194  }

◆ getVersion()

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

Definition at line 149 of file DataDictionary.h.

153  {

◆ hasFieldValue()

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

Definition at line 291 of file DataDictionary.h.

294  {
295  endPos = value.find_first_of(' ', startPos);

◆ isDataField()

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

Definition at line 358 of file DataDictionary.h.

359  { m_checkFieldsOutOfOrder = value; }
360  void checkFieldsHaveValues( bool value )
361  { m_checkFieldsHaveValues = value; }
362  void checkUserDefinedFields( bool value )

References m_checkFieldsOutOfOrder.

◆ isField()

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

Definition at line 196 of file DataDictionary.h.

197  {
199  {

References m_messageOrderedFields, and m_storeMsgFieldsOrder.

◆ isFieldValue()

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

Definition at line 297 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;

◆ isGroup()

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

Definition at line 330 of file DataDictionary.h.

344  {

Referenced by checkHasValue().

◆ isHeaderField()

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

Definition at line 238 of file DataDictionary.h.

239  {
240  return m_trailerFields.find( field ) != m_trailerFields.end();
241  }

References m_trailerFields.

◆ isMessageFieldsOrderPreserved()

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

Definition at line 383 of file DataDictionary.h.

383  :

◆ isMsgField()

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

Definition at line 221 of file DataDictionary.h.

224  {
225  return m_headerFields.find( field ) != m_headerFields.end();
226  }

◆ isMsgType()

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

Definition at line 206 of file DataDictionary.h.

207  {
208  MsgTypeToField::const_iterator i = m_messageFields.find( msgType );
209  if ( i == m_messageFields.end() ) return false;

References m_messageFields.

◆ isMultipleValueField()

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

Definition at line 364 of file DataDictionary.h.

365  { m_allowUnknownMessageFields = value; }
366  void preserveMessageFieldsOrder( bool value )
367  { m_storeMsgFieldsOrder = value; }
368  bool isMessageFieldsOrderPreserved() const
369  { return m_storeMsgFieldsOrder; }
370 

References m_allowUnknownMessageFields.

◆ isRequiredField()

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

Definition at line 279 of file DataDictionary.h.

283  {
284  FieldToValue::const_iterator i = m_fieldValues.find( field );

◆ isTrailerField()

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

Definition at line 253 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 381 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 144 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" );

References 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 410 of file DataDictionary.h.

415  {
416  try
417  {
418  TYPE::Type type = TYPE::Unknown;

Referenced by iterate().

◆ validate() [1/3]

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

Definition at line 391 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 allowUnknownMsgFields(), 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 601 of file DataDictionary.h.

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

◆ m_beginString

BeginString FIX::DataDictionary::m_beginString
private

Definition at line 604 of file DataDictionary.h.

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

◆ m_checkFieldsHaveValues

bool FIX::DataDictionary::m_checkFieldsHaveValues
private

Definition at line 599 of file DataDictionary.h.

Referenced by operator=().

◆ m_checkFieldsOutOfOrder

bool FIX::DataDictionary::m_checkFieldsOutOfOrder
private

Definition at line 598 of file DataDictionary.h.

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

◆ m_checkUserDefinedFields

bool FIX::DataDictionary::m_checkUserDefinedFields
private

Definition at line 600 of file DataDictionary.h.

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

◆ m_dataFields

MsgFields FIX::DataDictionary::m_dataFields
private

Definition at line 619 of file DataDictionary.h.

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

◆ m_fieldNames

FieldToName FIX::DataDictionary::m_fieldNames
private

Definition at line 615 of file DataDictionary.h.

Referenced by operator=().

◆ m_fields

Fields FIX::DataDictionary::m_fields
private

Definition at line 608 of file DataDictionary.h.

Referenced by operator=().

◆ m_fieldTypes

FieldTypes FIX::DataDictionary::m_fieldTypes
private

Definition at line 613 of file DataDictionary.h.

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

◆ m_fieldValues

FieldToValue FIX::DataDictionary::m_fieldValues
private

Definition at line 614 of file DataDictionary.h.

Referenced by operator=().

◆ m_groups

FieldToGroup FIX::DataDictionary::m_groups
private

Definition at line 618 of file DataDictionary.h.

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

◆ m_hasVersion

bool FIX::DataDictionary::m_hasVersion
private

Definition at line 597 of file DataDictionary.h.

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

◆ m_headerFields

NonBodyFields FIX::DataDictionary::m_headerFields
private

Definition at line 611 of file DataDictionary.h.

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

◆ m_headerOrder

OrderedFieldsArray FIX::DataDictionary::m_headerOrder
mutableprivate

Definition at line 621 of file DataDictionary.h.

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

◆ m_headerOrderedFields

OrderedFields FIX::DataDictionary::m_headerOrderedFields
private

Definition at line 620 of file DataDictionary.h.

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

◆ m_messageFields

MsgTypeToField FIX::DataDictionary::m_messageFields
private

Definition at line 605 of file DataDictionary.h.

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

◆ m_messageOrderedFields

MsgTypeToOrderedFields FIX::DataDictionary::m_messageOrderedFields
private

Definition at line 624 of file DataDictionary.h.

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

◆ m_messages

MsgTypes FIX::DataDictionary::m_messages
private

Definition at line 607 of file DataDictionary.h.

Referenced by operator=().

◆ m_names

NameToField FIX::DataDictionary::m_names
private

Definition at line 616 of file DataDictionary.h.

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

◆ m_orderedFields

OrderedFields FIX::DataDictionary::m_orderedFields
private

Definition at line 609 of file DataDictionary.h.

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

◆ m_orderedFieldsArray

OrderedFieldsArray FIX::DataDictionary::m_orderedFieldsArray
mutableprivate

Definition at line 610 of file DataDictionary.h.

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

◆ m_requiredFields

MsgTypeToField FIX::DataDictionary::m_requiredFields
private

Definition at line 606 of file DataDictionary.h.

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

◆ m_storeMsgFieldsOrder

bool FIX::DataDictionary::m_storeMsgFieldsOrder
private

Definition at line 602 of file DataDictionary.h.

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

◆ m_trailerFields

NonBodyFields FIX::DataDictionary::m_trailerFields
private

Definition at line 612 of file DataDictionary.h.

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

◆ m_trailerOrder

OrderedFieldsArray FIX::DataDictionary::m_trailerOrder
mutableprivate

Definition at line 623 of file DataDictionary.h.

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

◆ m_trailerOrderedFields

OrderedFields FIX::DataDictionary::m_trailerOrderedFields
private

Definition at line 622 of file DataDictionary.h.

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

◆ m_valueNames

ValueToName FIX::DataDictionary::m_valueNames
private

Definition at line 617 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:286
FIX::DataDictionary::m_orderedFieldsArray
OrderedFieldsArray m_orderedFieldsArray
Definition: DataDictionary.h:610
FIX::DataDictionary::m_checkFieldsHaveValues
bool m_checkFieldsHaveValues
Definition: DataDictionary.h:599
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:533
FIX::DataDictionary::setVersion
void setVersion(const std::string &beginString)
Definition: DataDictionary.h:144
FIX::DataDictionary::m_trailerFields
NonBodyFields m_trailerFields
Definition: DataDictionary.h:612
FIX::DataDictionary::m_orderedFields
OrderedFields m_orderedFields
Definition: DataDictionary.h:609
FIX::DataDictionary::getValueName
bool getValueName(int field, const std::string &value, std::string &name) const
Definition: DataDictionary.h:188
FIX::DataDictionary::readFromDocument
void readFromDocument(const DOMDocumentPtr &pDoc)
Definition: DataDictionary.cpp:234
FIX::DOMAttributesPtr
SmartPtr< DOMAttributes > DOMAttributesPtr
Definition: DOMDocument.h:45
FIX::TYPE::LocalMktDate
Definition: FieldTypes.h:940
FIX::TYPE::SeqNum
Definition: FieldTypes.h:951
FIX::TYPE::Percentage
Definition: FieldTypes.h:950
FIX::DataDictionary::checkIsInMessage
void checkIsInMessage(const FieldBase &field, const MsgType &msgType) const
Check if a field is in this message type.
Definition: DataDictionary.h:524
FIX::TYPE::UtcDate
Definition: FieldTypes.h:946
FIX::DataDictionary::readFromStream
void readFromStream(std::istream &stream)
Definition: DataDictionary.cpp:223
FIX::Exception
Base QuickFIX exception type.
Definition: Exceptions.h:48
FIX::CharConvertor::convert
static std::string convert(char value)
Definition: FieldConvertors.h:389
FIX::TYPE::PriceOffset
Definition: FieldTypes.h:943
FIX::TYPE::Price
Definition: FieldTypes.h:929
FIX::DataDictionary::hasFieldValue
bool hasFieldValue(int field) const
Definition: DataDictionary.h:291
FIX::DataDictionary::preserveMessageFieldsOrder
void preserveMessageFieldsOrder(bool value)
Definition: DataDictionary.h:381
FIX::TYPE::Char
Definition: FieldTypes.h:928
FIX::DataDictionary::getGroup
bool getGroup(const std::string &msg, int field, int &delim, const DataDictionary *&pDataDictionary) const
Definition: DataDictionary.h:341
FIX::DataDictionary::m_dataFields
MsgFields m_dataFields
Definition: DataDictionary.h:619
FIX::TYPE::NumInGroup
Definition: FieldTypes.h:949
FIX::TYPE::Int
Definition: FieldTypes.h:930
FIX::DataDictionary::m_storeMsgFieldsOrder
bool m_storeMsgFieldsOrder
Definition: DataDictionary.h:602
FIX::DataDictionary::m_trailerOrderedFields
OrderedFields m_trailerOrderedFields
Definition: DataDictionary.h:622
FIX::DataDictionary::checkUserDefinedFields
void checkUserDefinedFields(bool value)
Definition: DataDictionary.h:377
FIX::TYPE::MultipleValueString
Definition: FieldTypes.h:934
FIX::TYPE::DayOfMonth
Definition: FieldTypes.h:945
FIX::DataDictionary::m_beginString
BeginString m_beginString
Definition: DataDictionary.h:604
FIX::DataDictionary::addTrailerField
void addTrailerField(int field, bool required)
Definition: DataDictionary.h:243
FIX::TYPE::Boolean
Definition: FieldTypes.h:939
FIX::DataDictionary::m_fieldValues
FieldToValue m_fieldValues
Definition: DataDictionary.h:614
FIX::DataDictionary::m_checkFieldsOutOfOrder
bool m_checkFieldsOutOfOrder
Definition: DataDictionary.h:598
FIX::DataDictionary::isMsgField
bool isMsgField(const std::string &msgType, int field) const
Definition: DataDictionary.h:221
FIX::TYPE::TzTimeStamp
Definition: FieldTypes.h:955
FIX::DataDictionary::isRequiredField
bool isRequiredField(const std::string &msgType, int field) const
Definition: DataDictionary.h:279
FIX::UtcDateConvertor::convert
static std::string convert(const UtcDate &value)
Definition: FieldConvertors.h:650
FIX::DataDictionary::m_messages
MsgTypes m_messages
Definition: DataDictionary.h:607
FIX::DataDictionary::addValueName
void addValueName(int field, const std::string &value, const std::string &name)
Definition: DataDictionary.h:183
FIX::DataDictionary::readFromURL
void readFromURL(const std::string &url)
Definition: DataDictionary.cpp:205
FIX::DataDictionary::m_names
NameToField m_names
Definition: DataDictionary.h:616
FIX::DataDictionary::m_allowUnknownMessageFields
bool m_allowUnknownMessageFields
Definition: DataDictionary.h:601
FIX::TYPE::Currency
Definition: FieldTypes.h:933
FIX::DataDictionary::m_messageOrderedFields
MsgTypeToOrderedFields m_messageOrderedFields
Definition: DataDictionary.h:624
FIX::DataDictionary::m_trailerOrder
OrderedFieldsArray m_trailerOrder
Definition: DataDictionary.h:623
FIX::TYPE::UtcTimeStamp
Definition: FieldTypes.h:938
FIX::Message::isTrailerField
static bool isTrailerField(int field)
Definition: Message.cpp:565
FIX::IntConvertor::convert
static std::string convert(signed_int value)
Definition: FieldConvertors.h:168
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
Definition: FieldTypes.h:957
FIX::DataDictionary::checkValidTagNumber
void checkValidTagNumber(const FieldBase &field) const
Check if field tag number is defined in spec.
Definition: DataDictionary.h:421
FIX::TYPE::Amt
Definition: FieldTypes.h:931
FIX::DataDictionary::addField
void addField(int field)
Definition: DataDictionary.h:154
FIX::TYPE::Float
Definition: FieldTypes.h:942
FIX::DataDictionary::isMessageFieldsOrderPreserved
bool isMessageFieldsOrderPreserved() const
Definition: DataDictionary.h:383
FIX::DataDictionary::m_valueNames
ValueToName m_valueNames
Definition: DataDictionary.h:617
FIX::DataDictionary::m_messageFields
MsgTypeToField m_messageFields
Definition: DataDictionary.h:605
FIX::DataDictionary::m_headerOrderedFields
OrderedFields m_headerOrderedFields
Definition: DataDictionary.h:620
FIX::DataDictionary::isFieldValue
bool isFieldValue(int field, const std::string &value) const
Definition: DataDictionary.h:297
FIX::DataDictionary::addFieldName
void addFieldName(int field, const std::string &name)
Definition: DataDictionary.h:160
FIX::DataDictionary::addMsgType
void addMsgType(const std::string &msgType)
Definition: DataDictionary.h:201
FIX::DataDictionary::addXMLComponentFields
int addXMLComponentFields(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
Definition: DataDictionary.cpp:525
FIX::TYPE::UtcTimeOnly
Definition: FieldTypes.h:948
FIX::DataDictionary::lookupXMLFieldNumber
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const
Definition: DataDictionary.cpp:507
FIX::TYPE::String
Definition: FieldTypes.h:927
FIX::DataDictionary::isMultipleValueField
bool isMultipleValueField(int field) const
Definition: DataDictionary.h:364
FIX::DataDictionary::FieldPresenceMap
std::map< std::string, std::pair< int, DataDictionary * > > FieldPresenceMap
Definition: DataDictionary.h:124
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
Definition: FieldTypes.h:952
FIX::UtcTimeStampConvertor::convert
static std::string convert(const UtcTimeStamp &value, int precision=0)
Definition: FieldConvertors.h:449
FIX::DataDictionary::addHeaderField
void addHeaderField(int field, bool required)
Definition: DataDictionary.h:228
FIX::DataDictionary::m_groups
FieldToGroup m_groups
Definition: DataDictionary.h:618
FIX::DataDictionary::checkFieldsHaveValues
void checkFieldsHaveValues(bool value)
Definition: DataDictionary.h:375
FIX::DataDictionary::shouldCheckTag
bool shouldCheckTag(const FieldBase &field) const
If we need to check for the tag in the dictionary.
Definition: DataDictionary.h:410
FIX::FieldMap::g_const_iterator
Groups::const_iterator g_const_iterator
Definition: FieldMap.h:133
FIX::TYPE::XmlData
Definition: FieldTypes.h:956
FIX::DataDictionary::m_fieldTypes
FieldTypes m_fieldTypes
Definition: DataDictionary.h:613
FIX::DOMDocumentPtr
SmartPtr< DOMDocument > DOMDocumentPtr
Definition: DOMDocument.h:73
FIX::TYPE::Data
Definition: FieldTypes.h:941
FIX::BoolConvertor::convert
static std::string convert(bool value)
Definition: FieldConvertors.h:416
FIX::TYPE::Exchange
Definition: FieldTypes.h:937
FIX::DataDictionary::isGroup
bool isGroup(const std::string &msg, int field) const
Definition: DataDictionary.h:330
FIX::DataDictionary::addFieldType
void addFieldType(int field, FIX::TYPE::Type type)
Definition: DataDictionary.h:258
FIX::DataDictionary::m_hasVersion
bool m_hasVersion
Definition: DataDictionary.h:597
FIX::EmptyConvertor::convert
static const std::string & convert(const std::string &value)
Definition: FieldConvertors.h:159
FIX::TYPE::MonthYear
Definition: FieldTypes.h:944
FIX::Message::isHeaderField
static bool isHeaderField(int field)
Definition: Message.cpp:512
FIX::TYPE::TzTimeOnly
Definition: FieldTypes.h:954
FIX::DataDictionary::checkHasValue
void checkHasValue(const FieldBase &field) const
Check if a field has a value.
Definition: DataDictionary.h:515
FIX::DataDictionary::checkValue
void checkValue(const FieldBase &field) const
Definition: DataDictionary.h:504
FIX::DataDictionary::getVersion
std::string getVersion() const
Definition: DataDictionary.h:149
FIX::DataDictionary::m_checkUserDefinedFields
bool m_checkUserDefinedFields
Definition: DataDictionary.h:600
FIX::DataDictionary::m_requiredFields
MsgTypeToField m_requiredFields
Definition: DataDictionary.h:606
FIX::TYPE::Unknown
Definition: FieldTypes.h:926
FIX::TYPE::Qty
Definition: FieldTypes.h:932
FIX::TYPE::Country
Definition: FieldTypes.h:953
FIX::DataDictionary::m_fieldNames
FieldToName m_fieldNames
Definition: DataDictionary.h:615
FIX::DoubleConvertor::convert
static std::string convert(double value, int padding=0)
Definition: FieldConvertors.h:270
FIX::DataDictionary::addGroup
void addGroup(const std::string &msg, int field, int delim, const DataDictionary &dataDictionary)
Definition: DataDictionary.h:320
FIX::DataDictionary::m_headerFields
NonBodyFields m_headerFields
Definition: DataDictionary.h:611
FIX::TYPE::UtcDateOnly
Definition: FieldTypes.h:947
FIELD_GET_REF
#define FIELD_GET_REF(MAP, FLD)
Definition: FieldMap.h:375
FIX::DataDictionary::checkValidFormat
void checkValidFormat(const FieldBase &field) const
Definition: DataDictionary.h:428
FIX::DataDictionary::m_fields
Fields m_fields
Definition: DataDictionary.h:608
FIX::DataDictionary::addRequiredField
void addRequiredField(const std::string &msgType, int field)
Definition: DataDictionary.h:274
FIX::DataDictionary::getFieldType
bool getFieldType(int field, FIX::TYPE::Type &type) const
Definition: DataDictionary.h:266
FIX::TYPE::Type
Type
Definition: FieldTypes.h:924
FIX::UtcTimeOnlyConvertor::convert
static std::string convert(const UtcTimeOnly &value, int precision=0)
Definition: FieldConvertors.h:563
FIX::DataDictionary::DataDictionary
DataDictionary()
Definition: DataDictionary.cpp:41
FIX::DataDictionary::m_headerOrder
OrderedFieldsArray m_headerOrder
Definition: DataDictionary.h:621
FIX::DataDictionary::addMsgField
void addMsgField(const std::string &msgType, int field)
Definition: DataDictionary.h:211
FIX::TYPE::MultipleCharValue
Definition: FieldTypes.h:936
FIX::FieldMap::const_iterator
Fields::const_iterator const_iterator
Definition: FieldMap.h:131
FIX::TYPE::MultipleStringValue
Definition: FieldTypes.h:935

Generated on Thu Apr 23 2020 04:32:03 for QuickFIX by doxygen 1.8.16 written by Dimitri van Heesch, © 1997-2001