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

Member Typedef Documentation

◆ FieldPresenceMap

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

Definition at line 109 of file DataDictionary.h.

◆ Fields

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

Definition at line 54 of file DataDictionary.h.

◆ FieldToGroup

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

Definition at line 110 of file DataDictionary.h.

◆ FieldToName

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

Definition at line 101 of file DataDictionary.h.

◆ FieldToValue

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

Definition at line 100 of file DataDictionary.h.

◆ FieldTypes

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

Definition at line 98 of file DataDictionary.h.

◆ MsgFields

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

Definition at line 51 of file DataDictionary.h.

◆ MsgTypes

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

Definition at line 53 of file DataDictionary.h.

◆ MsgTypeToField

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

Definition at line 52 of file DataDictionary.h.

◆ MsgTypeToOrderedFields

Definition at line 95 of file DataDictionary.h.

◆ NameToField

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

Definition at line 102 of file DataDictionary.h.

◆ NonBodyFields

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

Definition at line 55 of file DataDictionary.h.

◆ OrderedFields

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

Definition at line 56 of file DataDictionary.h.

◆ OrderedFieldsArray

Definition at line 97 of file DataDictionary.h.

◆ Values

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

Definition at line 99 of file DataDictionary.h.

◆ ValueToName

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

Definition at line 103 of file DataDictionary.h.

Constructor & Destructor Documentation

◆ DataDictionary() [1/4]

FIX::DataDictionary::DataDictionary ( )

Definition at line 41 of file DataDictionary.cpp.

Referenced by addGroup().

◆ 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.

References readFromStream().

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

◆ DataDictionary() [4/4]

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

Definition at line 54 of file DataDictionary.cpp.

References readFromURL().

56 : m_hasVersion( false ), m_checkFieldsOutOfOrder( true ),
58 {
59  readFromURL( url );
60 }
void readFromURL(const std::string &url)
OrderedFieldsArray m_orderedFieldsArray

◆ ~DataDictionary()

FIX::DataDictionary::~DataDictionary ( )
virtual

Definition at line 67 of file DataDictionary.cpp.

References m_groups.

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 }
FieldToGroup m_groups
std::map< std::string, std::pair< int, DataDictionary *> > FieldPresenceMap

Member Function Documentation

◆ addField()

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

Definition at line 139 of file DataDictionary.h.

References m_fields, and m_orderedFields.

Referenced by addXMLComponentFields(), addXMLGroup(), and readFromDocument().

140  {
141  m_fields.insert( field );
142  m_orderedFields.push_back( field );
143  }
OrderedFields m_orderedFields

◆ addFieldName()

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

Definition at line 145 of file DataDictionary.h.

References m_fieldNames, and m_names.

Referenced by readFromDocument().

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  }
FieldToName m_fieldNames

◆ addFieldType()

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

Definition at line 243 of file DataDictionary.h.

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

Referenced by readFromDocument().

244  {
245  m_fieldTypes[ field ] = type;
246 
247  if( type == FIX::TYPE::Data )
248  m_dataFields.insert( field );
249  }

◆ addFieldValue()

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

Definition at line 271 of file DataDictionary.h.

References m_fieldValues.

Referenced by readFromDocument().

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

◆ addGroup()

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

Definition at line 305 of file DataDictionary.h.

References DataDictionary(), getVersion(), m_groups, and setVersion().

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

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  }
std::string getVersion() const
FieldToGroup m_groups
std::map< std::string, std::pair< int, DataDictionary *> > FieldPresenceMap

◆ addHeaderField()

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

Definition at line 213 of file DataDictionary.h.

References m_headerFields, m_headerOrderedFields, and m_storeMsgFieldsOrder.

Referenced by readFromDocument().

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

◆ addMsgField()

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

Definition at line 196 of file DataDictionary.h.

References m_messageFields, m_messageOrderedFields, and m_storeMsgFieldsOrder.

Referenced by addXMLComponentFields(), and readFromDocument().

197  {
199  {
200  m_messageOrderedFields[ msgType ].push_back(field);
201  }
202 
203  m_messageFields[ msgType ].insert( field );
204  }
MsgTypeToField m_messageFields
MsgTypeToOrderedFields m_messageOrderedFields

◆ addMsgType()

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

Definition at line 186 of file DataDictionary.h.

References m_messages.

Referenced by readFromDocument().

187  {
188  m_messages.insert( msgType );
189  }

◆ addRequiredField()

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

Definition at line 259 of file DataDictionary.h.

References m_requiredFields.

Referenced by addXMLComponentFields(), addXMLGroup(), and readFromDocument().

260  {
261  m_requiredFields[ msgType ].insert( field );
262  }
MsgTypeToField m_requiredFields

◆ addTrailerField()

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

Definition at line 228 of file DataDictionary.h.

References m_storeMsgFieldsOrder, m_trailerFields, and m_trailerOrderedFields.

Referenced by readFromDocument().

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

◆ addValueName()

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

Definition at line 168 of file DataDictionary.h.

References m_valueNames.

Referenced by readFromDocument().

169  {
170  m_valueNames[std::make_pair(field, value)] = name;
171  }
ValueToName m_valueNames

◆ 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.

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

Referenced by addXMLGroup(), checkHasRequired(), and readFromDocument().

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 }
void addXMLGroup(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
#define RESET_AUTO_PTR(OLD, NEW)
int addXMLComponentFields(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
SmartPtr< DOMAttributes > DOMAttributesPtr
Definition: DOMDocument.h:45
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const
SmartPtr< DOMNode > DOMNodePtr
Definition: DOMDocument.h:59
void addRequiredField(const std::string &msgType, int field)

◆ 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.

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

Referenced by addXMLComponentFields(), checkHasRequired(), and readFromDocument().

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 }
void addXMLGroup(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
#define RESET_AUTO_PTR(OLD, NEW)
int addXMLComponentFields(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
SmartPtr< DOMAttributes > DOMAttributesPtr
Definition: DOMDocument.h:45
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const
SmartPtr< DOMNode > DOMNodePtr
Definition: DOMDocument.h:59

◆ allowUnknownMsgFields()

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

Definition at line 364 of file DataDictionary.h.

References m_allowUnknownMessageFields.

365  { m_allowUnknownMessageFields = value; }

◆ checkFieldsHaveValues()

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

Definition at line 360 of file DataDictionary.h.

References m_checkFieldsHaveValues.

361  { m_checkFieldsHaveValues = value; }

◆ checkFieldsOutOfOrder()

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

Definition at line 358 of file DataDictionary.h.

References m_checkFieldsOutOfOrder.

359  { m_checkFieldsOutOfOrder = value; }

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

References checkHasRequired(), FIX::IntConvertor::convert(), FIX::FieldBase::getString(), FIX::FieldBase::getTag(), FIX::FieldMap::groupCount(), and isGroup().

Referenced by checkIsInMessage(), and iterate().

520  {
521  int fieldNum = field.getTag();
522  if( isGroup(msgType, fieldNum) )
523  {
524  if( (int)fieldMap.groupCount(fieldNum)
525  != IntConvertor::convert(field.getString()) )
526  throw RepeatingGroupCountMismatch(fieldNum);
527  }
528  }
static std::string convert(signed_int value)
bool isGroup(const std::string &msg, int field) const

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

References addXMLComponentFields(), addXMLGroup(), checkHasRequired(), FIX::FieldMap::g_begin(), FIX::FieldMap::g_end(), getGroup(), FIX::FieldMap::isSetField(), lookupXMLFieldNumber(), m_headerFields, m_requiredFields, m_trailerFields, and XMLTypeToType().

Referenced by checkGroupCount(), and checkHasRequired().

535  {
536  NonBodyFields::const_iterator iNBF;
537  for( iNBF = m_headerFields.begin(); iNBF != m_headerFields.end(); ++iNBF )
538  {
539  if( iNBF->second == true && !header.isSetField(iNBF->first) )
540  throw RequiredTagMissing( iNBF->first );
541  }
542 
543  for( iNBF = m_trailerFields.begin(); iNBF != m_trailerFields.end(); ++iNBF )
544  {
545  if( iNBF->second == true && !trailer.isSetField(iNBF->first) )
546  throw RequiredTagMissing( iNBF->first );
547  }
548 
549  MsgTypeToField::const_iterator iM
550  = m_requiredFields.find( msgType.getString() );
551  if ( iM == m_requiredFields.end() ) return ;
552 
553  const MsgFields& fields = iM->second;
554  MsgFields::const_iterator iF;
555  for( iF = fields.begin(); iF != fields.end(); ++iF )
556  {
557  if( !body.isSetField(*iF) )
558  throw RequiredTagMissing( *iF );
559  }
560 
562  for( groups = body.g_begin(); groups != body.g_end(); ++groups )
563  {
564  int delim;
565  const DataDictionary* DD = 0;
566  int field = groups->first;
567  if( getGroup( msgType.getValue(), field, delim, DD ) )
568  {
569  std::vector<FieldMap*>::const_iterator group;
570  for( group = groups->second.begin(); group != groups->second.end(); ++group )
571  DD->checkHasRequired( **group, **group, **group, msgType );
572  }
573  }
574  }
MsgTypeToField m_requiredFields
bool getGroup(const std::string &msg, int field, int &delim, const DataDictionary *&pDataDictionary) const
NonBodyFields m_headerFields
Groups::const_iterator g_const_iterator
Definition: FieldMap.h:102
std::set< int > MsgFields
NonBodyFields m_trailerFields

◆ checkHasValue()

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

Check if a field has a value.

Definition at line 500 of file DataDictionary.h.

References checkIsInMessage(), and m_checkFieldsHaveValues.

Referenced by iterate().

502  {
503  if ( m_checkFieldsHaveValues && !field.getString().length() )
504  throw NoTagValue( field.getTag() );
505  }

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

References checkGroupCount(), FIX::FieldBase::getTag(), and isMsgField().

Referenced by checkHasValue(), and iterate().

511  {
512  if ( !isMsgField( msgType, field.getTag() ) )
513  throw TagNotDefinedForMessage( field.getTag() );
514  }
bool isMsgField(const std::string &msgType, int field) const

◆ checkMsgType()

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

Check if message type is defined in spec.

Definition at line 388 of file DataDictionary.h.

References isMsgType().

389  {
390  if ( !isMsgType( msgType.getValue() ) )
391  throw InvalidMessageType();
392  }
bool isMsgType(const std::string &msgType) const

◆ checkUserDefinedFields()

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

Definition at line 362 of file DataDictionary.h.

References m_checkUserDefinedFields.

363  { m_checkUserDefinedFields = value; }

◆ checkValidFormat()

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

Definition at line 413 of file DataDictionary.h.

References FIX::TYPE::Amt, FIX::TYPE::Boolean, FIX::TYPE::Char, FIX::EmptyConvertor::convert(), FIX::IntConvertor::convert(), FIX::DoubleConvertor::convert(), FIX::CharConvertor::convert(), FIX::BoolConvertor::convert(), FIX::UtcTimeStampConvertor::convert(), FIX::UtcTimeOnlyConvertor::convert(), FIX::UtcDateConvertor::convert(), FIX::TYPE::Country, FIX::TYPE::Currency, FIX::TYPE::Data, FIX::TYPE::DayOfMonth, FIX::TYPE::Exchange, FIX::TYPE::Float, getFieldType(), FIX::TYPE::Int, FIX::TYPE::Language, FIX::TYPE::Length, FIX::TYPE::LocalMktDate, 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::TzTimeOnly, FIX::TYPE::TzTimeStamp, FIX::TYPE::Unknown, FIX::TYPE::UtcDate, FIX::TYPE::UtcTimeOnly, FIX::TYPE::UtcTimeStamp, and FIX::TYPE::XmlData.

Referenced by iterate().

415  {
416  try
417  {
418  TYPE::Type type = TYPE::Unknown;
419  getFieldType( field.getTag(), type );
420  switch ( type )
421  {
422  case TYPE::String:
423  STRING_CONVERTOR::convert( field.getString() ); break;
424  case TYPE::Char:
425  CHAR_CONVERTOR::convert( field.getString() ); break;
426  case TYPE::Price:
427  PRICE_CONVERTOR::convert( field.getString() ); break;
428  case TYPE::Int:
429  INT_CONVERTOR::convert( field.getString() ); break;
430  case TYPE::Amt:
431  AMT_CONVERTOR::convert( field.getString() ); break;
432  case TYPE::Qty:
433  QTY_CONVERTOR::convert( field.getString() ); break;
434  case TYPE::Currency:
435  CURRENCY_CONVERTOR::convert( field.getString() ); break;
437  MULTIPLEVALUESTRING_CONVERTOR::convert( field.getString() ); break;
439  MULTIPLESTRINGVALUE_CONVERTOR::convert( field.getString() ); break;
441  MULTIPLECHARVALUE_CONVERTOR::convert( field.getString() ); break;
442  case TYPE::Exchange:
443  EXCHANGE_CONVERTOR::convert( field.getString() ); break;
444  case TYPE::UtcTimeStamp:
445  UTCTIMESTAMP_CONVERTOR::convert( field.getString() ); break;
446  case TYPE::Boolean:
447  BOOLEAN_CONVERTOR::convert( field.getString() ); break;
448  case TYPE::LocalMktDate:
449  LOCALMKTDATE_CONVERTOR::convert( field.getString() ); break;
450  case TYPE::Data:
451  DATA_CONVERTOR::convert( field.getString() ); break;
452  case TYPE::Float:
453  FLOAT_CONVERTOR::convert( field.getString() ); break;
454  case TYPE::PriceOffset:
455  PRICEOFFSET_CONVERTOR::convert( field.getString() ); break;
456  case TYPE::MonthYear:
457  MONTHYEAR_CONVERTOR::convert( field.getString() ); break;
458  case TYPE::DayOfMonth:
459  DAYOFMONTH_CONVERTOR::convert( field.getString() ); break;
460  case TYPE::UtcDate:
461  UTCDATE_CONVERTOR::convert( field.getString() ); break;
462  case TYPE::UtcTimeOnly:
463  UTCTIMEONLY_CONVERTOR::convert( field.getString() ); break;
464  case TYPE::NumInGroup:
465  NUMINGROUP_CONVERTOR::convert( field.getString() ); break;
466  case TYPE::Percentage:
467  PERCENTAGE_CONVERTOR::convert( field.getString() ); break;
468  case TYPE::SeqNum:
469  SEQNUM_CONVERTOR::convert( field.getString() ); break;
470  case TYPE::Length:
471  LENGTH_CONVERTOR::convert( field.getString() ); break;
472  case TYPE::Country:
473  COUNTRY_CONVERTOR::convert( field.getString() ); break;
474  case TYPE::TzTimeOnly:
475  TZTIMEONLY_CONVERTOR::convert( field.getString() ); break;
476  case TYPE::TzTimeStamp:
477  TZTIMESTAMP_CONVERTOR::convert( field.getString() ); break;
478  case TYPE::XmlData:
479  XMLDATA_CONVERTOR::convert( field.getString() ); break;
480  case TYPE::Language:
481  LANGUAGE_CONVERTOR::convert( field.getString() ); break;
482  case TYPE::Unknown: break;
483  }
484  }
485  catch ( FieldConvertError& )
486  { throw IncorrectDataFormat( field.getTag(), field.getString() ); }
487  }
static std::string convert(const UtcTimeOnly &value, int precision=0)
static std::string convert(char value)
bool getFieldType(int field, FIX::TYPE::Type &type) const
static std::string convert(signed_int value)
static std::string convert(const UtcTimeStamp &value, int precision=0)
static std::string convert(double value, int padding=0)
static std::string convert(const UtcDate &value)
static std::string convert(bool value)
static const std::string & convert(const std::string &value)

◆ checkValidTagNumber()

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

Check if field tag number is defined in spec.

Definition at line 406 of file DataDictionary.h.

References m_fields.

Referenced by iterate().

408  {
409  if( m_fields.find( field.getTag() ) == m_fields.end() )
410  throw InvalidTagNumber( field.getTag() );
411  }

◆ checkValue()

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

Definition at line 489 of file DataDictionary.h.

References hasFieldValue(), and isFieldValue().

Referenced by iterate().

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  }
bool hasFieldValue(int field) const
bool isFieldValue(int field, const std::string &value) const

◆ getFieldName()

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

Definition at line 152 of file DataDictionary.h.

References m_fieldNames.

153  {
154  FieldToName::const_iterator i = m_fieldNames.find( field );
155  if(i == m_fieldNames.end()) return false;
156  name = i->second;
157  return true;
158  }
FieldToName m_fieldNames

◆ getFieldTag()

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

Definition at line 160 of file DataDictionary.h.

References m_names.

161  {
162  NameToField::const_iterator i = m_names.find( name );
163  if(i == m_names.end()) return false;
164  field = i->second;
165  return true;
166  }

◆ getFieldType()

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

Definition at line 251 of file DataDictionary.h.

References m_fieldTypes.

Referenced by checkValidFormat().

252  {
253  FieldTypes::const_iterator i = m_fieldTypes.find( field );
254  if ( i == m_fieldTypes.end() ) return false;
255  type = i->second;
256  return true;
257  }

◆ getGroup()

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

Definition at line 326 of file DataDictionary.h.

References m_groups.

Referenced by checkHasRequired(), and FIX::Message::setGroup().

328  {
329  FieldToGroup::const_iterator i = m_groups.find( field );
330  if ( i == m_groups.end() ) return false;
331 
332  const FieldPresenceMap& presenceMap = i->second;
333 
334  FieldPresenceMap::const_iterator iter = presenceMap.find( msg );
335  if( iter == presenceMap.end() ) return false;
336 
337  std::pair < int, DataDictionary* > pair = iter->second;
338  delim = pair.first;
339  pDataDictionary = pair.second;
340  return true;
341  }
FieldToGroup m_groups
std::map< std::string, std::pair< int, DataDictionary *> > FieldPresenceMap

◆ getHeaderOrderedFields()

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

Definition at line 458 of file DataDictionary.cpp.

References m_headerOrder, and m_headerOrderedFields.

Referenced by FIX::Session::newMessage(), and FIX::Session::nextResendRequest().

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 }
OrderedFields m_headerOrderedFields
OrderedFieldsArray m_headerOrder

◆ getMessageOrderedFields()

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

Definition at line 498 of file DataDictionary.cpp.

References m_messageOrderedFields.

Referenced by FIX::Session::newMessage(), and FIX::Session::nextResendRequest().

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 }
MsgTypeToOrderedFields m_messageOrderedFields

◆ getOrderedFields()

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

Definition at line 441 of file DataDictionary.cpp.

References m_orderedFields, and m_orderedFieldsArray.

Referenced by FIX::Message::setGroup().

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 }
OrderedFields m_orderedFields
OrderedFieldsArray m_orderedFieldsArray

◆ getTrailerOrderedFields()

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

Definition at line 478 of file DataDictionary.cpp.

References m_trailerOrder, and m_trailerOrderedFields.

Referenced by FIX::Session::newMessage(), and FIX::Session::nextResendRequest().

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 }
OrderedFieldsArray m_trailerOrder
OrderedFields m_trailerOrderedFields

◆ getValueName()

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

Definition at line 173 of file DataDictionary.h.

References m_valueNames.

174  {
175  ValueToName::const_iterator i = m_valueNames.find( std::make_pair(field, value) );
176  if(i == m_valueNames.end()) return false;
177  name = i->second;
178  return true;
179  }
ValueToName m_valueNames

◆ getVersion()

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

Definition at line 134 of file DataDictionary.h.

References m_beginString.

Referenced by addGroup().

135  {
136  return m_beginString.getString();
137  }
BeginString m_beginString

◆ hasFieldValue()

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

Definition at line 276 of file DataDictionary.h.

References m_fieldValues.

Referenced by checkValue().

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

◆ isDataField()

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

Definition at line 343 of file DataDictionary.h.

References m_dataFields.

Referenced by FIX::Message::IsDataField().

344  {
345  MsgFields::const_iterator iter = m_dataFields.find( field );
346  return iter != m_dataFields.end();
347  }

◆ isField()

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

Definition at line 181 of file DataDictionary.h.

References m_fields.

Referenced by FIX::Message::setGroup().

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

◆ isFieldValue()

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

Definition at line 282 of file DataDictionary.h.

References isMultipleValueField(), and m_fieldValues.

Referenced by checkValue().

283  {
284  FieldToValue::const_iterator i = m_fieldValues.find( field );
285  if ( i == m_fieldValues.end() )
286  return false;
287  if( !isMultipleValueField( field ) )
288  return i->second.find( value ) != i->second.end();
289 
290  // MultipleValue
291  std::string::size_type startPos = 0;
292  std::string::size_type endPos = 0;
293  do
294  {
295  endPos = value.find_first_of(' ', startPos);
296  std::string singleValue =
297  value.substr( startPos, endPos - startPos );
298  if( i->second.find( singleValue ) == i->second.end() )
299  return false;
300  startPos = endPos + 1;
301  } while( endPos != std::string::npos );
302  return true;
303  }
bool isMultipleValueField(int field) const
FieldToValue m_fieldValues

◆ isGroup()

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

Definition at line 315 of file DataDictionary.h.

References m_groups.

Referenced by checkGroupCount().

316  {
317  FieldToGroup::const_iterator i = m_groups.find( field );
318  if ( i == m_groups.end() ) return false;
319 
320  const FieldPresenceMap& presenceMap = i->second;
321 
322  FieldPresenceMap::const_iterator iter = presenceMap.find( msg );
323  return ( iter != presenceMap.end() );
324  }
FieldToGroup m_groups
std::map< std::string, std::pair< int, DataDictionary *> > FieldPresenceMap

◆ isHeaderField()

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

Definition at line 223 of file DataDictionary.h.

References m_headerFields.

Referenced by FIX::Message::isHeaderField().

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

◆ isMessageFieldsOrderPreserved()

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

Definition at line 368 of file DataDictionary.h.

References m_storeMsgFieldsOrder, and validate().

Referenced by FIX::Session::newMessage(), and FIX::Session::nextResendRequest().

369  { return m_storeMsgFieldsOrder; }

◆ isMsgField()

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

Definition at line 206 of file DataDictionary.h.

References m_messageFields.

Referenced by checkIsInMessage().

207  {
208  MsgTypeToField::const_iterator i = m_messageFields.find( msgType );
209  if ( i == m_messageFields.end() ) return false;
210  return i->second.find( field ) != i->second.end();
211  }
MsgTypeToField m_messageFields

◆ isMsgType()

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

Definition at line 191 of file DataDictionary.h.

References m_messages.

Referenced by checkMsgType().

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

◆ isMultipleValueField()

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

Definition at line 349 of file DataDictionary.h.

References m_fieldTypes, FIX::TYPE::MultipleCharValue, FIX::TYPE::MultipleStringValue, and FIX::TYPE::MultipleValueString.

Referenced by isFieldValue().

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  }

◆ isRequiredField()

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

Definition at line 264 of file DataDictionary.h.

References m_requiredFields.

265  {
266  MsgTypeToField::const_iterator i = m_requiredFields.find( msgType );
267  if ( i == m_requiredFields.end() ) return false;
268  return i->second.find( field ) != i->second.end();
269  }
MsgTypeToField m_requiredFields

◆ isTrailerField()

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

Definition at line 238 of file DataDictionary.h.

References m_trailerFields.

Referenced by FIX::Message::isTrailerField().

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

◆ 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.

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

Referenced by validate().

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 }
void checkGroupCount(const FieldBase &field, const FieldMap &fieldMap, const MsgType &msgType) const
Check if group count matches number of groups in.
void checkValidFormat(const FieldBase &field) const
BeginString m_beginString
void checkIsInMessage(const FieldBase &field, const MsgType &msgType) const
Check if a field is in this message type.
void checkValue(const FieldBase &field) const
bool shouldCheckTag(const FieldBase &field) const
If we need to check for the tag in the dictionary.
Fields::const_iterator const_iterator
Definition: FieldMap.h:100
void checkValidTagNumber(const FieldBase &field) const
Check if field tag number is defined in spec.
void checkHasValue(const FieldBase &field) const
Check if a field has a value.
static bool isHeaderField(int field)
Definition: Message.cpp:497
static bool isTrailerField(int field)
Definition: Message.cpp:550

◆ lookupXMLFieldNumber() [1/2]

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

Definition at line 507 of file DataDictionary.cpp.

References FIX::DOMNode::getAttributes().

Referenced by addXMLComponentFields(), addXMLGroup(), checkHasRequired(), and readFromDocument().

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 }
SmartPtr< DOMAttributes > DOMAttributesPtr
Definition: DOMDocument.h:45
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const

◆ lookupXMLFieldNumber() [2/2]

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

Definition at line 517 of file DataDictionary.cpp.

References m_names.

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 }

◆ operator=()

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

Definition at line 80 of file DataDictionary.cpp.

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.

Referenced by validate().

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 }
MsgTypeToField m_requiredFields
OrderedFields m_headerOrderedFields
OrderedFields m_orderedFields
void addGroup(const std::string &msg, int field, int delim, const DataDictionary &dataDictionary)
NonBodyFields m_headerFields
FieldToName m_fieldNames
BeginString m_beginString
MsgTypeToField m_messageFields
OrderedFieldsArray m_trailerOrder
FieldToValue m_fieldValues
OrderedFields m_trailerOrderedFields
ValueToName m_valueNames
MsgTypeToOrderedFields m_messageOrderedFields
OrderedFieldsArray m_headerOrder
std::map< std::string, std::pair< int, DataDictionary *> > FieldPresenceMap
NonBodyFields m_trailerFields
OrderedFieldsArray m_orderedFieldsArray

◆ preserveMessageFieldsOrder()

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

Definition at line 366 of file DataDictionary.h.

References m_storeMsgFieldsOrder.

367  { m_storeMsgFieldsOrder = value; }

◆ readFromDocument()

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

Definition at line 234 of file DataDictionary.cpp.

References addField(), addFieldName(), addFieldType(), addFieldValue(), addHeaderField(), addMsgField(), addMsgType(), addRequiredField(), addTrailerField(), addValueName(), addXMLComponentFields(), addXMLGroup(), lookupXMLFieldNumber(), RESET_AUTO_PTR, setVersion(), and XMLTypeToType().

Referenced by readFromStream(), and readFromURL().

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 }
void addMsgField(const std::string &msgType, int field)
void addTrailerField(int field, bool required)
void addXMLGroup(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
#define RESET_AUTO_PTR(OLD, NEW)
int addXMLComponentFields(DOMDocument *, DOMNode *, const std::string &msgtype, DataDictionary &, bool)
SmartPtr< DOMAttributes > DOMAttributesPtr
Definition: DOMDocument.h:45
void addHeaderField(int field, bool required)
void addValueName(int field, const std::string &value, const std::string &name)
int lookupXMLFieldNumber(DOMDocument *, DOMNode *) const
SmartPtr< DOMNode > DOMNodePtr
Definition: DOMDocument.h:59
void addField(int field)
void addFieldName(int field, const std::string &name)
void setVersion(const std::string &beginString)
void addFieldValue(int field, const std::string &value)
void addMsgType(const std::string &msgType)
void addFieldType(int field, FIX::TYPE::Type type)
TYPE::Type XMLTypeToType(const std::string &xmlType) const
void addRequiredField(const std::string &msgType, int field)

◆ readFromStream()

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

Definition at line 223 of file DataDictionary.cpp.

References readFromDocument().

Referenced by DataDictionary().

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 }
void readFromDocument(const DOMDocumentPtr &pDoc)
SmartPtr< DOMDocument > DOMDocumentPtr
Definition: DOMDocument.h:73

◆ readFromURL()

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

Definition at line 205 of file DataDictionary.cpp.

References readFromDocument().

Referenced by DataDictionary().

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 }
void readFromDocument(const DOMDocumentPtr &pDoc)
SmartPtr< DOMDocument > DOMDocumentPtr
Definition: DOMDocument.h:73

◆ setVersion()

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

Definition at line 129 of file DataDictionary.h.

References m_beginString, and m_hasVersion.

Referenced by addGroup(), and readFromDocument().

130  {
131  m_beginString = beginString;
132  m_hasVersion = true;
133  }
BeginString m_beginString

◆ shouldCheckTag()

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

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

Definition at line 395 of file DataDictionary.h.

References FIX::FieldBase::getTag(), m_allowUnknownMessageFields, m_checkUserDefinedFields, and FIX::FIELD::UserMin.

Referenced by iterate().

396  {
397  if( m_allowUnknownMessageFields && field.getTag() < FIELD::UserMin )
398  return false;
399  else if( !m_checkUserDefinedFields && field.getTag() >= FIELD::UserMin )
400  return false;
401  else
402  return true;
403  }
const int UserMin
Definition: FieldNumbers.h:40

◆ validate() [1/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.

References FIX::FIELD::BeginString, FIELD_GET_REF, and FIX::FIELD::MsgType.

Referenced by isMessageFieldsOrderPreserved(), FIX::Session::next(), and validate().

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 }
const int BeginString
#define FIELD_GET_REF(MAP, FLD)
Definition: FieldMap.h:376
const int MsgType

◆ validate() [2/3]

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

Definition at line 376 of file DataDictionary.h.

References validate().

377  { validate( message, false ); }
static void validate(const Message &message, const DataDictionary *const pSessionDD, const DataDictionary *const pAppID)
Validate a message.

◆ validate() [3/3]

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

Definition at line 378 of file DataDictionary.h.

References iterate(), FIX::FIELD::MsgType, operator=(), and validate().

379  { validate( message, bodyOnly ? (DataDictionary*)0 : this, this ); }
static void validate(const Message &message, const DataDictionary *const pSessionDD, const DataDictionary *const pAppID)
Validate a message.

◆ XMLTypeToType()

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

Definition at line 646 of file DataDictionary.cpp.

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.

Referenced by checkHasRequired(), and readFromDocument().

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 }
BeginString m_beginString

Member Data Documentation

◆ m_allowUnknownMessageFields

bool FIX::DataDictionary::m_allowUnknownMessageFields
private

Definition at line 586 of file DataDictionary.h.

Referenced by allowUnknownMsgFields(), operator=(), and shouldCheckTag().

◆ m_beginString

BeginString FIX::DataDictionary::m_beginString
private

Definition at line 589 of file DataDictionary.h.

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

◆ m_checkFieldsHaveValues

bool FIX::DataDictionary::m_checkFieldsHaveValues
private

Definition at line 584 of file DataDictionary.h.

Referenced by checkFieldsHaveValues(), checkHasValue(), and operator=().

◆ m_checkFieldsOutOfOrder

bool FIX::DataDictionary::m_checkFieldsOutOfOrder
private

Definition at line 583 of file DataDictionary.h.

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

◆ m_checkUserDefinedFields

bool FIX::DataDictionary::m_checkUserDefinedFields
private

Definition at line 585 of file DataDictionary.h.

Referenced by checkUserDefinedFields(), operator=(), and shouldCheckTag().

◆ m_dataFields

MsgFields FIX::DataDictionary::m_dataFields
private

Definition at line 604 of file DataDictionary.h.

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

◆ m_fieldNames

FieldToName FIX::DataDictionary::m_fieldNames
private

Definition at line 600 of file DataDictionary.h.

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

◆ m_fields

Fields FIX::DataDictionary::m_fields
private

Definition at line 593 of file DataDictionary.h.

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

◆ m_fieldTypes

FieldTypes FIX::DataDictionary::m_fieldTypes
private

Definition at line 598 of file DataDictionary.h.

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

◆ m_fieldValues

FieldToValue FIX::DataDictionary::m_fieldValues
private

Definition at line 599 of file DataDictionary.h.

Referenced by addFieldValue(), hasFieldValue(), isFieldValue(), and operator=().

◆ m_groups

FieldToGroup FIX::DataDictionary::m_groups
private

Definition at line 603 of file DataDictionary.h.

Referenced by addGroup(), getGroup(), isGroup(), operator=(), and ~DataDictionary().

◆ m_hasVersion

bool FIX::DataDictionary::m_hasVersion
private

Definition at line 582 of file DataDictionary.h.

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

◆ m_headerFields

NonBodyFields FIX::DataDictionary::m_headerFields
private

Definition at line 596 of file DataDictionary.h.

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

◆ m_headerOrder

OrderedFieldsArray FIX::DataDictionary::m_headerOrder
mutableprivate

Definition at line 606 of file DataDictionary.h.

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

◆ m_headerOrderedFields

OrderedFields FIX::DataDictionary::m_headerOrderedFields
private

Definition at line 605 of file DataDictionary.h.

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

◆ m_messageFields

MsgTypeToField FIX::DataDictionary::m_messageFields
private

Definition at line 590 of file DataDictionary.h.

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

◆ m_messageOrderedFields

MsgTypeToOrderedFields FIX::DataDictionary::m_messageOrderedFields
private

Definition at line 609 of file DataDictionary.h.

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

◆ m_messages

MsgTypes FIX::DataDictionary::m_messages
private

Definition at line 592 of file DataDictionary.h.

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

◆ m_names

NameToField FIX::DataDictionary::m_names
private

Definition at line 601 of file DataDictionary.h.

Referenced by addFieldName(), getFieldTag(), lookupXMLFieldNumber(), and operator=().

◆ m_orderedFields

OrderedFields FIX::DataDictionary::m_orderedFields
private

Definition at line 594 of file DataDictionary.h.

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

◆ m_orderedFieldsArray

OrderedFieldsArray FIX::DataDictionary::m_orderedFieldsArray
mutableprivate

Definition at line 595 of file DataDictionary.h.

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

◆ m_requiredFields

MsgTypeToField FIX::DataDictionary::m_requiredFields
private

Definition at line 591 of file DataDictionary.h.

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

◆ m_storeMsgFieldsOrder

bool FIX::DataDictionary::m_storeMsgFieldsOrder
private

◆ m_trailerFields

NonBodyFields FIX::DataDictionary::m_trailerFields
private

Definition at line 597 of file DataDictionary.h.

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

◆ m_trailerOrder

OrderedFieldsArray FIX::DataDictionary::m_trailerOrder
mutableprivate

Definition at line 608 of file DataDictionary.h.

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

◆ m_trailerOrderedFields

OrderedFields FIX::DataDictionary::m_trailerOrderedFields
private

Definition at line 607 of file DataDictionary.h.

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

◆ m_valueNames

ValueToName FIX::DataDictionary::m_valueNames
private

Definition at line 602 of file DataDictionary.h.

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


The documentation for this class was generated from the following files:

Generated on Sun Apr 15 2018 21:44:05 for QuickFIX by doxygen 1.8.13 written by Dimitri van Heesch, © 1997-2001