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.
 

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.
 
void checkMsgType (const MsgType &msgType) const
 Check if message type is defined in spec.
 
bool shouldCheckTag (const FieldBase &field) const
 If we need to check for the tag in the dictionary.
 
void checkValidTagNumber (const FieldBase &field) const throw ( InvalidTagNumber )
 Check if field tag number is defined in spec.
 
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.
 
void checkIsInMessage (const FieldBase &field, const MsgType &msgType) const throw ( TagNotDefinedForMessage )
 Check if a field is in this message type.
 
void checkGroupCount (const FieldBase &field, const FieldMap &fieldMap, const MsgType &msgType) const throw ( RepeatingGroupCountMismatch )
 Check if group count matches number of groups in.
 
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.
 
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 ( )

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

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

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

References m_groups.

Member Function Documentation

◆ addField()

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

Definition at line 139 of file DataDictionary.h.

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

References m_fields, and m_orderedFields.

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ addFieldName()

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

Definition at line 145 of file DataDictionary.h.

146 {
147 if( m_names.insert( std::make_pair(name, field) ).second == false )
148 throw ConfigError( "Field named " + name + " defined multiple times" );
149 m_fieldNames[field] = name;
150 }

References m_fieldNames, and m_names.

◆ addFieldType()

void FIX::DataDictionary::addFieldType ( int  field,
FIX::TYPE::Type  type 
)
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 }

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

◆ addFieldValue()

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

Definition at line 271 of file DataDictionary.h.

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

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

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

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

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

◆ addHeaderField()

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

Definition at line 213 of file DataDictionary.h.

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

References m_headerFields, m_headerOrderedFields, and m_storeMsgFieldsOrder.

◆ addMsgField()

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

Definition at line 196 of file DataDictionary.h.

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

References m_messageFields, m_messageOrderedFields, and m_storeMsgFieldsOrder.

Referenced by addXMLComponentFields().

◆ addMsgType()

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

Definition at line 186 of file DataDictionary.h.

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

References m_messages.

◆ addRequiredField()

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

Definition at line 259 of file DataDictionary.h.

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

References m_requiredFields.

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ addTrailerField()

void FIX::DataDictionary::addTrailerField ( 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 }
OrderedFields m_trailerOrderedFields
NonBodyFields m_trailerFields

References m_storeMsgFieldsOrder, m_trailerFields, and m_trailerOrderedFields.

◆ addValueName()

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

Definition at line 168 of file DataDictionary.h.

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

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

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

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

Referenced by addXMLComponentFields(), and 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(), addXMLGroup(), FIX::DOMNode::getAttributes(), FIX::DOMNode::getFirstChildNode(), lookupXMLFieldNumber(), and RESET_AUTO_PTR.

Referenced by addXMLComponentFields(), and addXMLGroup().

◆ allowUnknownMsgFields()

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

Definition at line 364 of file DataDictionary.h.

365 { m_allowUnknownMessageFields = value; }

References m_allowUnknownMessageFields.

◆ checkFieldsHaveValues()

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

Definition at line 360 of file DataDictionary.h.

361 { m_checkFieldsHaveValues = value; }

References m_checkFieldsHaveValues.

◆ checkFieldsOutOfOrder()

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

Definition at line 358 of file DataDictionary.h.

359 { m_checkFieldsOutOfOrder = value; }

References m_checkFieldsOutOfOrder.

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

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 }
bool isGroup(const std::string &msg, int field) const
static std::string convert(signed_int value)

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

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

535 {
536 NonBodyFields::const_iterator iNBF;
537 for( iNBF = m_headerFields.begin(); iNBF != m_headerFields.end(); ++iNBF )
538 {
539 if( iNBF->second == true && !header.isSetField(iNBF->first) )
540 throw RequiredTagMissing( iNBF->first );
541 }
542
543 for( iNBF = m_trailerFields.begin(); iNBF != m_trailerFields.end(); ++iNBF )
544 {
545 if( iNBF->second == true && !trailer.isSetField(iNBF->first) )
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 }
std::set< int > MsgFields
bool getGroup(const std::string &msg, int field, int &delim, const DataDictionary *&pDataDictionary) const
Groups::const_iterator g_const_iterator
Definition FieldMap.h:102

References checkHasRequired(), getGroup(), m_headerFields, m_requiredFields, and m_trailerFields.

Referenced by checkHasRequired().

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

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

References m_checkFieldsHaveValues.

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

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

References isMsgField().

Referenced by iterate().

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

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

References isMsgType().

◆ checkUserDefinedFields()

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

Definition at line 362 of file DataDictionary.h.

363 { m_checkUserDefinedFields = value; }

References m_checkUserDefinedFields.

◆ checkValidFormat()

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

Definition at line 413 of file DataDictionary.h.

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

References FIX::TYPE::Amt, FIX::TYPE::Boolean, FIX::TYPE::Char, FIX::BoolConvertor::convert(), FIX::CharConvertor::convert(), FIX::EmptyConvertor::convert(), FIX::UtcDateConvertor::convert(), FIX::UtcTimeOnlyConvertor::convert(), FIX::UtcTimeStampConvertor::convert(), FIX::DoubleConvertor::convert(), FIX::IntConvertor::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().

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

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

References m_fields.

Referenced by iterate().

◆ checkValue()

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

Definition at line 489 of file DataDictionary.h.

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

References hasFieldValue(), and isFieldValue().

Referenced by iterate().

◆ getFieldName()

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

Definition at line 152 of file DataDictionary.h.

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 }

References m_fieldNames.

◆ getFieldTag()

bool FIX::DataDictionary::getFieldTag ( const std::string &  name,
int &  field 
) const
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;
166 }

References m_names.

◆ getFieldType()

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

Definition at line 251 of file DataDictionary.h.

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 }

References m_fieldTypes.

Referenced by checkValidFormat().

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

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 }

References m_groups.

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

◆ 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}
OrderedFieldsArray m_headerOrder

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
456}

References m_orderedFields, and m_orderedFieldsArray.

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

◆ 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}
OrderedFieldsArray m_trailerOrder

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

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 }

References m_valueNames.

◆ getVersion()

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

Definition at line 134 of file DataDictionary.h.

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

References m_beginString.

Referenced by addGroup().

◆ hasFieldValue()

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

Definition at line 276 of file DataDictionary.h.

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

References m_fieldValues.

Referenced by checkValue().

◆ isDataField()

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

Definition at line 343 of file DataDictionary.h.

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

References m_dataFields.

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

◆ isField()

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

Definition at line 181 of file DataDictionary.h.

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

References m_fields.

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

◆ isFieldValue()

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

Definition at line 282 of file DataDictionary.h.

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

References isMultipleValueField(), and m_fieldValues.

Referenced by checkValue().

◆ isGroup()

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

Definition at line 315 of file DataDictionary.h.

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 }

References m_groups.

Referenced by checkGroupCount().

◆ isHeaderField()

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

Definition at line 223 of file DataDictionary.h.

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

References m_headerFields.

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

◆ isMessageFieldsOrderPreserved()

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

Definition at line 368 of file DataDictionary.h.

369 { return m_storeMsgFieldsOrder; }

References m_storeMsgFieldsOrder.

◆ isMsgField()

bool FIX::DataDictionary::isMsgField ( const std::string &  msgType,
int  field 
) 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;
210 return i->second.find( field ) != i->second.end();
211 }

References m_messageFields.

Referenced by checkIsInMessage().

◆ isMsgType()

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

Definition at line 191 of file DataDictionary.h.

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

References m_messages.

Referenced by checkMsgType().

◆ isMultipleValueField()

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

Definition at line 349 of file DataDictionary.h.

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 }

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

Referenced by isFieldValue().

◆ isRequiredField()

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

Definition at line 264 of file DataDictionary.h.

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 }

References m_requiredFields.

◆ isTrailerField()

bool FIX::DataDictionary::isTrailerField ( 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.

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

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

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 516 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}

References m_names.

◆ 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(), and lookupXMLFieldNumber().

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

◆ 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}
void addGroup(const std::string &msg, int field, int delim, const DataDictionary &dataDictionary)

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

367 { m_storeMsgFieldsOrder = value; }

References m_storeMsgFieldsOrder.

◆ 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}
void addValueName(int field, const std::string &value, const std::string &name)
void addMsgField(const std::string &msgType, int field)
void addMsgType(const std::string &msgType)
void addField(int field)
void addFieldValue(int field, const std::string &value)
TYPE::Type XMLTypeToType(const std::string &xmlType) const
void addFieldType(int field, FIX::TYPE::Type type)
void addHeaderField(int field, bool required)
void setVersion(const std::string &beginString)
void addFieldName(int field, const std::string &name)
void addTrailerField(int field, bool required)

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

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

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

References m_beginString, and m_hasVersion.

Referenced by addGroup().

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

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

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

Referenced by iterate().

◆ validate() [1/3]

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

Definition at line 376 of file DataDictionary.h.

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

References validate().

◆ validate() [2/3]

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

Definition at line 378 of file DataDictionary.h.

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

References validate().

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

References FIELD_GET_REF.

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

◆ 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 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(), 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 Sat Feb 3 2024 04:23:15 for QuickFIX by doxygen 1.9.8 written by Dimitri van Heesch, © 1997-2001