Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes
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]

List of all members.

Public Member Functions

 DataDictionary ()
 DataDictionary (const DataDictionary &copy)
 DataDictionary (std::istream &stream) throw ( ConfigError )
 DataDictionary (const std::string &url) throw ( ConfigError )
virtual ~DataDictionary ()
void readFromURL (const std::string &url) throw ( ConfigError )
void readFromDocument (DOMDocumentPtr pDoc) throw ( ConfigError )
void readFromStream (std::istream &stream) throw ( ConfigError )
message_order const & getOrderedFields () const
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 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,
MsgFields
MsgTypeToField
typedef std::set< std::string > MsgTypes
typedef std::set< int > Fields
typedef std::map< int, bool > NonBodyFields
typedef std::vector< int > OrderedFields
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,
FieldPresenceMap
FieldToGroup

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.
void readMSXMLDOM (const std::string &)
 Read XML file using MSXML.
void readMSXML (const std::string &)
void readLibXml (const std::string &)
 Read XML file using libXML.
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
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

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

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

Definition at line 69 of file DataDictionary.h.

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

Definition at line 54 of file DataDictionary.h.

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

Definition at line 70 of file DataDictionary.h.

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

Definition at line 61 of file DataDictionary.h.

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

Definition at line 60 of file DataDictionary.h.

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

Definition at line 58 of file DataDictionary.h.

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

Definition at line 51 of file DataDictionary.h.

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

Definition at line 53 of file DataDictionary.h.

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

Definition at line 52 of file DataDictionary.h.

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

Definition at line 62 of file DataDictionary.h.

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

Definition at line 55 of file DataDictionary.h.

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

Definition at line 56 of file DataDictionary.h.

Definition at line 57 of file DataDictionary.h.

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

Definition at line 59 of file DataDictionary.h.

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

Definition at line 63 of file DataDictionary.h.


Constructor & Destructor Documentation

Definition at line 47 of file DataDictionary.cpp.

Referenced by addGroup().

Definition at line 69 of file DataDictionary.cpp.

{
  *this = copy;
}
FIX::DataDictionary::DataDictionary ( std::istream &  stream) throw ( ConfigError )

Definition at line 52 of file DataDictionary.cpp.

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

Definition at line 60 of file DataDictionary.cpp.

Definition at line 74 of file DataDictionary.cpp.

References m_groups.

{
  FieldToGroup::iterator i;
  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
  {
    const FieldPresenceMap& presenceMap = i->second;

    FieldPresenceMap::const_iterator iter = presenceMap.begin();
    for ( ; iter != presenceMap.end(); ++iter )
      delete iter->second.second;
}
}

Member Function Documentation

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

Definition at line 96 of file DataDictionary.h.

References m_fields, and m_orderedFields.

Referenced by addXMLComponentFields(), and addXMLGroup().

  {
    m_fields.insert( field );
    m_orderedFields.push_back( field );
  }
void FIX::DataDictionary::addFieldName ( int  field,
const std::string &  name 
) [inline]

Definition at line 102 of file DataDictionary.h.

References m_fieldNames, and m_names.

  {
    if( m_names.insert( std::make_pair(name, field) ).second == false )
      throw ConfigError( "Field named " + name + " defined multiple times" );
    m_fieldNames[field] = name;
  }
void FIX::DataDictionary::addFieldType ( int  field,
FIX::TYPE::Type  type 
) [inline]

Definition at line 185 of file DataDictionary.h.

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

  {
    m_fieldTypes[ field ] = type;

    if( type == FIX::TYPE::Data )
      m_dataFields.insert( field );
  }
void FIX::DataDictionary::addFieldValue ( int  field,
const std::string &  value 
) [inline]

Definition at line 213 of file DataDictionary.h.

References m_fieldValues.

  {
    m_fieldValues[ field ].insert( value );
  }
void FIX::DataDictionary::addGroup ( const std::string &  msg,
int  field,
int  delim,
const DataDictionary dataDictionary 
) [inline]

Definition at line 247 of file DataDictionary.h.

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

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

  {
    DataDictionary * pDD = new DataDictionary( dataDictionary );
    pDD->setVersion( getVersion() );

    FieldPresenceMap& presenceMap = m_groups[ field ];
    presenceMap[ msg ] = std::make_pair( delim, pDD );
  }
void FIX::DataDictionary::addHeaderField ( int  field,
bool  required 
) [inline]

Definition at line 165 of file DataDictionary.h.

References m_headerFields.

  {
    m_headerFields[ field ] = required;
  }
void FIX::DataDictionary::addMsgField ( const std::string &  msgType,
int  field 
) [inline]

Definition at line 153 of file DataDictionary.h.

References m_messageFields.

Referenced by addXMLComponentFields().

  {
    m_messageFields[ msgType ].insert( field );
  }
void FIX::DataDictionary::addMsgType ( const std::string &  msgType) [inline]

Definition at line 143 of file DataDictionary.h.

References m_messages.

  {
    m_messages.insert( msgType );
  }
void FIX::DataDictionary::addRequiredField ( const std::string &  msgType,
int  field 
) [inline]

Definition at line 201 of file DataDictionary.h.

References m_requiredFields.

Referenced by addXMLComponentFields(), and addXMLGroup().

  {
    m_requiredFields[ msgType ].insert( field );
  }
void FIX::DataDictionary::addTrailerField ( int  field,
bool  required 
) [inline]

Definition at line 175 of file DataDictionary.h.

References m_trailerFields.

  {
    m_trailerFields[ field ] = required;
  }
void FIX::DataDictionary::addValueName ( int  field,
const std::string &  value,
const std::string &  name 
) [inline]

Definition at line 125 of file DataDictionary.h.

References m_valueNames.

  {
    m_valueNames[std::make_pair(field, value)] = name;
  }
int FIX::DataDictionary::addXMLComponentFields ( DOMDocument pDoc,
DOMNode pNode,
const std::string &  msgtype,
DataDictionary DD,
bool  componentRequired 
) [private]

Definition at line 480 of file DataDictionary.cpp.

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

Referenced by addXMLGroup().

{
  int firstField = 0;

  DOMAttributesPtr attrs = pNode->getAttributes();
  std::string name;
  if(!attrs->get("name", name))
    throw ConfigError("No name given to component");

  DOMNodePtr pComponentNode =
    pDoc->getNode("/fix/components/component[@name='" + name + "']");
  if(pComponentNode.get() == 0)
    throw ConfigError("Component not found");

  DOMNodePtr pComponentFieldNode = pComponentNode->getFirstChildNode();
  while(pComponentFieldNode.get())
  {
    if(pComponentFieldNode->getName() == "field"
       || pComponentFieldNode->getName() == "group")
    {
      DOMAttributesPtr attrs = pComponentFieldNode->getAttributes();
      std::string name;
      if(!attrs->get("name", name))
        throw ConfigError("No name given to field");
      int field = lookupXMLFieldNumber(pDoc, name);
      if( firstField == 0 ) firstField = field;

      std::string required;
      if(attrs->get("required", required)
         && (required == "Y" || required =="y")
         && componentRequired)
      {
        addRequiredField(msgtype, field);
      }

      DD.addField(field);
      DD.addMsgField(msgtype, field);
    }
    if(pComponentFieldNode->getName() == "component")
    {
      DOMAttributesPtr attrs = pComponentFieldNode->getAttributes();
      std::string required;
      attrs->get("required", required);
      bool isRequired = (required == "Y" || required == "y");
      addXMLComponentFields(pDoc, pComponentFieldNode.get(),
                            msgtype, DD, isRequired);
    }
    if(pComponentFieldNode->getName() == "group")
    {
      DOMAttributesPtr attrs = pComponentFieldNode->getAttributes();
      std::string required;
      attrs->get("required", required);
      bool isRequired = (required == "Y" || required == "y");
      addXMLGroup(pDoc, pComponentFieldNode.get(), msgtype, DD, isRequired);
    }
    RESET_AUTO_PTR(pComponentFieldNode,
      pComponentFieldNode->getNextSiblingNode());
  }
  return firstField;
}
void FIX::DataDictionary::addXMLGroup ( DOMDocument pDoc,
DOMNode pNode,
const std::string &  msgtype,
DataDictionary DD,
bool  groupRequired 
) [private]

Definition at line 544 of file DataDictionary.cpp.

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

Referenced by addXMLComponentFields().

{
  DOMAttributesPtr attrs = pNode->getAttributes();
  std::string name;
  if(!attrs->get("name", name))
    throw ConfigError("No name given to group");
  int group = lookupXMLFieldNumber( pDoc, name );
  int delim = 0;
  int field = 0;
  DataDictionary groupDD;
  DOMNodePtr node = pNode->getFirstChildNode();
  while(node.get())
  {
    if( node->getName() == "field" )
    {
      field = lookupXMLFieldNumber( pDoc, node.get() );
      groupDD.addField( field );

      DOMAttributesPtr attrs = node->getAttributes();
      std::string required;
      if( attrs->get("required", required)
         && ( required == "Y" || required =="y" )
         && groupRequired )
      {
        groupDD.addRequiredField(msgtype, field);
      }
    }
    else if( node->getName() == "component" )
    {
      field = addXMLComponentFields( pDoc, node.get(), msgtype, groupDD, false );
    }
    else if( node->getName() == "group" )
    {
      field = lookupXMLFieldNumber( pDoc, node.get() );
      groupDD.addField( field );
      DOMAttributesPtr attrs = node->getAttributes();
      std::string required;
      if( attrs->get("required", required )
         && ( required == "Y" || required =="y" )
         && groupRequired)
      {
        groupDD.addRequiredField(msgtype, field);
      }
      bool isRequired = false;
      if( attrs->get("required", required) )
      isRequired = (required == "Y" || required == "y");
      addXMLGroup( pDoc, node.get(), msgtype, groupDD, isRequired );
    }
    if( delim == 0 ) delim = field;
    RESET_AUTO_PTR(node, node->getNextSiblingNode());
  }

  if( delim ) DD.addGroup( msgtype, group, delim, groupDD );
}
void FIX::DataDictionary::checkFieldsHaveValues ( bool  value) [inline]

Definition at line 302 of file DataDictionary.h.

References m_checkFieldsHaveValues.

Referenced by FIX::SessionFactory::createDataDictionary().

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

Definition at line 300 of file DataDictionary.h.

References m_checkFieldsOutOfOrder.

Referenced by FIX::SessionFactory::createDataDictionary().

void FIX::DataDictionary::checkGroupCount ( const FieldBase field,
const FieldMap fieldMap,
const MsgType &  msgType 
) const throw ( RepeatingGroupCountMismatch ) [inline, private]

Check if group count matches number of groups in.

Definition at line 452 of file DataDictionary.h.

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

Referenced by iterate().

  {
    int fieldNum = field.getField();
    if( isGroup(msgType, fieldNum) )
    {
      if( fieldMap.groupCount(fieldNum)
        != IntConvertor::convert(field.getString()) )
      throw RepeatingGroupCountMismatch(fieldNum);
    }
  }
void FIX::DataDictionary::checkHasRequired ( const FieldMap header,
const FieldMap body,
const FieldMap trailer,
const MsgType &  msgType 
) const throw ( RequiredTagMissing ) [inline, private]

Check if a message has all required fields.

Definition at line 466 of file DataDictionary.h.

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

Referenced by checkHasRequired().

  {
    NonBodyFields::const_iterator iNBF;
    for( iNBF = m_headerFields.begin(); iNBF != m_headerFields.end(); ++iNBF )
    {
      if( iNBF->second == true && !header.isSetField(iNBF->first) )
        throw RequiredTagMissing( iNBF->first );
    }

    for( iNBF = m_trailerFields.begin(); iNBF != m_trailerFields.end(); ++iNBF )
    {
      if( iNBF->second == true && !trailer.isSetField(iNBF->first) )
        throw RequiredTagMissing( iNBF->first );
    }

    MsgTypeToField::const_iterator iM
      = m_requiredFields.find( msgType.getString() );
    if ( iM == m_requiredFields.end() ) return ;

    const MsgFields& fields = iM->second;
    MsgFields::const_iterator iF;
    for( iF = fields.begin(); iF != fields.end(); ++iF )
    {
      if( !body.isSetField(*iF) )
        throw RequiredTagMissing( *iF );
    }

    FieldMap::g_iterator groups;
    for( groups = body.g_begin(); groups != body.g_end(); ++groups )
    {
      int delim;
      const DataDictionary* DD = 0;
      int field = groups->first;
      if( getGroup( msgType.getValue(), field, delim, DD ) )
      {
        std::vector<FieldMap*>::const_iterator group;
        for( group = groups->second.begin(); group != groups->second.end(); ++group )
          DD->checkHasRequired( **group, **group, **group, msgType );
      }
    }
  }
void FIX::DataDictionary::checkHasValue ( const FieldBase field) const throw ( NoTagValue ) [inline, private]

Check if a field has a value.

Definition at line 434 of file DataDictionary.h.

References m_checkFieldsHaveValues.

Referenced by iterate().

  {
    if ( m_checkFieldsHaveValues && !field.getString().length() )
      throw NoTagValue( field.getField() );
  }
void FIX::DataDictionary::checkIsInMessage ( const FieldBase field,
const MsgType &  msgType 
) const throw ( TagNotDefinedForMessage ) [inline, private]

Check if a field is in this message type.

Definition at line 443 of file DataDictionary.h.

References FIX::FieldBase::getField(), and isMsgField().

Referenced by iterate().

  {
    if ( !isMsgField( msgType, field.getField() ) )
      throw TagNotDefinedForMessage( field.getField() );
  }
void FIX::DataDictionary::checkMsgType ( const MsgType &  msgType) const [inline, private]

Check if message type is defined in spec.

Definition at line 324 of file DataDictionary.h.

References isMsgType().

  {
    if ( !isMsgType( msgType.getValue() ) )
      throw InvalidMessageType();
  }
void FIX::DataDictionary::checkUserDefinedFields ( bool  value) [inline]

Definition at line 304 of file DataDictionary.h.

References m_checkUserDefinedFields.

Referenced by FIX::SessionFactory::createDataDictionary().

void FIX::DataDictionary::checkValidFormat ( const FieldBase field) const throw ( IncorrectDataFormat ) [inline, private]

Definition at line 347 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().

  {
    try
    {
      TYPE::Type type = TYPE::Unknown;
      getFieldType( field.getField(), type );
      switch ( type )
      {
      case TYPE::String:
        STRING_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Char:
        CHAR_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Price:
        PRICE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Int:
        INT_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Amt:
        AMT_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Qty:
        QTY_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Currency:
        CURRENCY_CONVERTOR::convert( field.getString() ); break;
      case TYPE::MultipleValueString:
        MULTIPLEVALUESTRING_CONVERTOR::convert( field.getString() ); break;
      case TYPE::MultipleStringValue:
        MULTIPLESTRINGVALUE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::MultipleCharValue:
        MULTIPLECHARVALUE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Exchange:
        EXCHANGE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::UtcTimeStamp:
        UTCTIMESTAMP_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Boolean:
        BOOLEAN_CONVERTOR::convert( field.getString() ); break;
      case TYPE::LocalMktDate:
        LOCALMKTDATE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Data:
        DATA_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Float:
        FLOAT_CONVERTOR::convert( field.getString() ); break;
      case TYPE::PriceOffset:
        PRICEOFFSET_CONVERTOR::convert( field.getString() ); break;
      case TYPE::MonthYear:
        MONTHYEAR_CONVERTOR::convert( field.getString() ); break;
      case TYPE::DayOfMonth:
        DAYOFMONTH_CONVERTOR::convert( field.getString() ); break;
      case TYPE::UtcDate:
        UTCDATE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::UtcTimeOnly:
        UTCTIMEONLY_CONVERTOR::convert( field.getString() ); break;
      case TYPE::NumInGroup:
        NUMINGROUP_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Percentage:
        PERCENTAGE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::SeqNum:
        SEQNUM_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Length:
        LENGTH_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Country:
        COUNTRY_CONVERTOR::convert( field.getString() ); break;
      case TYPE::TzTimeOnly:
        TZTIMEONLY_CONVERTOR::convert( field.getString() ); break;
      case TYPE::TzTimeStamp:
        TZTIMESTAMP_CONVERTOR::convert( field.getString() ); break;
      case TYPE::XmlData:
        XMLDATA_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Language:
        LANGUAGE_CONVERTOR::convert( field.getString() ); break;
      case TYPE::Unknown: break;
      }
    }
    catch ( FieldConvertError& )
    { throw IncorrectDataFormat( field.getField(), field.getString() ); }
  }
void FIX::DataDictionary::checkValidTagNumber ( const FieldBase field) const throw ( InvalidTagNumber ) [inline, private]

Check if field tag number is defined in spec.

Definition at line 340 of file DataDictionary.h.

References m_fields.

Referenced by iterate().

  {
    if( m_fields.find( field.getField() ) == m_fields.end() )
      throw InvalidTagNumber( field.getField() );
  }
void FIX::DataDictionary::checkValue ( const FieldBase field) const throw ( IncorrectTagValue ) [inline, private]

Definition at line 423 of file DataDictionary.h.

References hasFieldValue(), and isFieldValue().

Referenced by iterate().

  {
    if ( !hasFieldValue( field.getField() ) ) return ;

    const std::string& value = field.getString();
    if ( !isFieldValue( field.getField(), value ) )
      throw IncorrectTagValue( field.getField() );
  }
bool FIX::DataDictionary::getFieldName ( int  field,
std::string &  name 
) const [inline]

Definition at line 109 of file DataDictionary.h.

References m_fieldNames.

  {
    FieldToName::const_iterator i = m_fieldNames.find( field );
    if(i == m_fieldNames.end()) return false;
    name = i->second;
    return true;
  }
bool FIX::DataDictionary::getFieldTag ( const std::string &  name,
int &  field 
) const [inline]

Definition at line 117 of file DataDictionary.h.

References m_names.

  {
    NameToField::const_iterator i = m_names.find( name );
    if(i == m_names.end()) return false;
    field = i->second;
    return true;
  }
bool FIX::DataDictionary::getFieldType ( int  field,
FIX::TYPE::Type type 
) const [inline]

Definition at line 193 of file DataDictionary.h.

References m_fieldTypes.

Referenced by checkValidFormat().

  {
    FieldTypes::const_iterator i = m_fieldTypes.find( field );
    if ( i == m_fieldTypes.end() ) return false;
    type = i->second;
    return true;
  }
bool FIX::DataDictionary::getGroup ( const std::string &  msg,
int  field,
int &  delim,
const DataDictionary *&  pDataDictionary 
) const [inline]

Definition at line 268 of file DataDictionary.h.

References m_groups.

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

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

    const FieldPresenceMap& presenceMap = i->second;

    FieldPresenceMap::const_iterator iter = presenceMap.find( msg );
    if( iter == presenceMap.end() ) return false;

    std::pair < int, DataDictionary* > pair = iter->second;
    delim = pair.first;
    pDataDictionary = pair.second;
    return true;
  }

Definition at line 445 of file DataDictionary.cpp.

References m_orderedFields, and m_orderedFieldsArray.

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

{
  if( m_orderedFieldsArray ) return m_orderedFieldsArray;

  int * tmp = new int[m_orderedFields.size() + 1];
  int * i = tmp;

  OrderedFields::const_iterator iter;
  for( iter = m_orderedFields.begin(); iter != m_orderedFields.end(); *(i++) = *(iter++) ) {}
  *i = 0;

  m_orderedFieldsArray = message_order(tmp);
  delete [] tmp;

  return m_orderedFieldsArray;
}
bool FIX::DataDictionary::getValueName ( int  field,
const std::string &  value,
std::string &  name 
) const [inline]

Definition at line 130 of file DataDictionary.h.

References m_valueNames.

  {
    ValueToName::const_iterator i = m_valueNames.find( std::make_pair(field, value) );
    if(i == m_valueNames.end()) return false;
    name = i->second;
    return true;
  }
std::string FIX::DataDictionary::getVersion ( ) const [inline]

Definition at line 91 of file DataDictionary.h.

References m_beginString.

Referenced by addGroup().

  {
    return m_beginString.getString();
  }
bool FIX::DataDictionary::hasFieldValue ( int  field) const [inline]

Definition at line 218 of file DataDictionary.h.

References m_fieldValues.

Referenced by checkValue().

  {
    FieldToValue::const_iterator i = m_fieldValues.find( field );
    return i != m_fieldValues.end();
  }
bool FIX::DataDictionary::isDataField ( int  field) const [inline]

Definition at line 285 of file DataDictionary.h.

References m_dataFields.

  {
    MsgFields::const_iterator iter = m_dataFields.find( field );
    return iter != m_dataFields.end();
  }
bool FIX::DataDictionary::isField ( int  field) const [inline]

Definition at line 138 of file DataDictionary.h.

References m_fields.

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

  {
    return m_fields.find( field ) != m_fields.end();
  }
bool FIX::DataDictionary::isFieldValue ( int  field,
const std::string &  value 
) const [inline]

Definition at line 224 of file DataDictionary.h.

References isMultipleValueField(), and m_fieldValues.

Referenced by checkValue().

  {
    FieldToValue::const_iterator i = m_fieldValues.find( field );
    if ( i == m_fieldValues.end() )
      return false;
    if( !isMultipleValueField( field ) )
      return i->second.find( value ) != i->second.end();

    // MultipleValue
    std::string::size_type startPos = 0;
    std::string::size_type endPos = 0;
    do
    {
      endPos = value.find_first_of(' ', startPos);
      std::string singleValue =
        value.substr( startPos, endPos - startPos );
      if( i->second.find( singleValue ) == i->second.end() )
        return false;
      startPos = endPos + 1;
    } while( endPos != std::string::npos );
    return true;
  }
bool FIX::DataDictionary::isGroup ( const std::string &  msg,
int  field 
) const [inline]

Definition at line 257 of file DataDictionary.h.

References m_groups.

Referenced by checkGroupCount().

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

    const FieldPresenceMap& presenceMap = i->second;

    FieldPresenceMap::const_iterator iter = presenceMap.find( msg );
    return ( iter != presenceMap.end() );
  }
bool FIX::DataDictionary::isHeaderField ( int  field) const [inline]

Definition at line 170 of file DataDictionary.h.

References m_headerFields.

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

  {
    return m_headerFields.find( field ) != m_headerFields.end();
  }
bool FIX::DataDictionary::isMsgField ( const std::string &  msgType,
int  field 
) const [inline]

Definition at line 158 of file DataDictionary.h.

References m_messageFields.

Referenced by checkIsInMessage().

  {
    MsgTypeToField::const_iterator i = m_messageFields.find( msgType );
    if ( i == m_messageFields.end() ) return false;
    return i->second.find( field ) != i->second.end();
  }
bool FIX::DataDictionary::isMsgType ( const std::string &  msgType) const [inline]

Definition at line 148 of file DataDictionary.h.

References m_messages.

Referenced by checkMsgType().

  {
    return m_messages.find( msgType ) != m_messages.end();
  }
bool FIX::DataDictionary::isMultipleValueField ( int  field) const [inline]

Definition at line 291 of file DataDictionary.h.

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

Referenced by isFieldValue().

  {
    FieldTypes::const_iterator i = m_fieldTypes.find( field );
    return i != m_fieldTypes.end() 
      && (i->second == TYPE::MultipleValueString 
          || i->second == TYPE::MultipleCharValue 
          || i->second == TYPE::MultipleStringValue );
  }
bool FIX::DataDictionary::isRequiredField ( const std::string &  msgType,
int  field 
) const [inline]

Definition at line 206 of file DataDictionary.h.

References m_requiredFields.

  {
    MsgTypeToField::const_iterator i = m_requiredFields.find( msgType );
    if ( i == m_requiredFields.end() ) return false;
    return i->second.find( field ) != i->second.end();
  }
bool FIX::DataDictionary::isTrailerField ( int  field) const [inline]

Definition at line 180 of file DataDictionary.h.

References m_trailerFields.

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

  {
    return m_trailerFields.find( field ) != m_trailerFields.end();
  }
void FIX::DataDictionary::iterate ( const FieldMap map,
const MsgType &  msgType 
) const [private]

Iterate through fields while applying checks.

Definition at line 165 of file DataDictionary.cpp.

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

{
  int lastField = 0;

  FieldMap::iterator i;
  for ( i = map.begin(); i != map.end(); ++i )
  {
    const FieldBase& field = i->second;
    if( i != map.begin() && (field.getField() == lastField) )
      throw RepeatedTag( lastField );
    checkHasValue( field );

    if ( m_hasVersion )
    {
      checkValidFormat( field );
      checkValue( field );
    }

    if ( m_beginString.getValue().length() && shouldCheckTag(field) )
    {
      checkValidTagNumber( field );
      if ( !Message::isHeaderField( field, this )
           && !Message::isTrailerField( field, this ) )
      {
        checkIsInMessage( field, msgType );
        checkGroupCount( field, map, msgType );
      }
    }
    lastField = field.getField();
  }
}
int FIX::DataDictionary::lookupXMLFieldNumber ( DOMDocument pDoc,
DOMNode pNode 
) const [private]

Definition at line 462 of file DataDictionary.cpp.

References FIX::DOMNode::getAttributes().

Referenced by addXMLComponentFields(), and addXMLGroup().

{
  DOMAttributesPtr attrs = pNode->getAttributes();
  std::string name;
  if(!attrs->get("name", name))
    throw ConfigError("No name given to field");
  return lookupXMLFieldNumber( pDoc, name );
}
int FIX::DataDictionary::lookupXMLFieldNumber ( DOMDocument pDoc,
const std::string &  name 
) const [private]

Definition at line 472 of file DataDictionary.cpp.

{
  NameToField::const_iterator i = m_names.find(name);
  if( i == m_names.end() )
    throw ConfigError("Field " + name + " not defined in fields section");
  return i->second;
}
DataDictionary & FIX::DataDictionary::operator= ( const DataDictionary rhs)

Definition at line 87 of file DataDictionary.cpp.

References addGroup(), 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_messageFields, m_messages, m_names, m_orderedFields, m_orderedFieldsArray, m_requiredFields, m_trailerFields, and m_valueNames.

{
  m_hasVersion = rhs.m_hasVersion;
  m_checkFieldsOutOfOrder = rhs.m_checkFieldsOutOfOrder;
  m_checkFieldsHaveValues = rhs.m_checkFieldsHaveValues;
  m_checkUserDefinedFields = rhs.m_checkUserDefinedFields;
  m_beginString = rhs.m_beginString;
  m_messageFields = rhs.m_messageFields;
  m_requiredFields = rhs.m_requiredFields;
  m_messages = rhs.m_messages;
  m_fields = rhs.m_fields;
  m_orderedFields = rhs.m_orderedFields;
  m_orderedFieldsArray = rhs.m_orderedFieldsArray;
  m_headerFields = rhs.m_headerFields;
  m_trailerFields = rhs.m_trailerFields;
  m_fieldTypes = rhs.m_fieldTypes;
  m_fieldValues = rhs.m_fieldValues;
  m_fieldNames = rhs.m_fieldNames;
  m_names = rhs.m_names;
  m_valueNames = rhs.m_valueNames;
  m_dataFields = rhs.m_dataFields;

  FieldToGroup::const_iterator i = rhs.m_groups.begin();
  for ( ; i != rhs.m_groups.end(); ++i )
  {
    const FieldPresenceMap& presenceMap = i->second;

    FieldPresenceMap::const_iterator iter = presenceMap.begin();
    for ( ; iter != presenceMap.end(); ++iter )
    {
      addGroup( iter->first, i->first, iter->second.first, *iter->second.second );
  }
  }
  return *this;
}

Definition at line 238 of file DataDictionary.cpp.

References RESET_AUTO_PTR.

{
  // VERSION
  DOMNodePtr pFixNode = pDoc->getNode("/fix");
  if(!pFixNode.get())
    throw ConfigError("Could not parse data dictionary file"
                      ", or no <fix> node found at root");
  DOMAttributesPtr attrs = pFixNode->getAttributes();
  std::string type = "FIX";
  if(attrs->get("type", type))
  {
    if(type != "FIX" && type != "FIXT")
      throw ConfigError("type attribute must be FIX or FIXT");
  }
  std::string major;
  if(!attrs->get("major", major))
    throw ConfigError("major attribute not found on <fix>");
  std::string minor;
  if(!attrs->get("minor", minor))
    throw ConfigError("minor attribute not found on <fix>");
  setVersion(type + "." + major + "." + minor);

  // FIELDS
  DOMNodePtr pFieldsNode = pDoc->getNode("/fix/fields");
  if(!pFieldsNode.get())
    throw ConfigError("<fields> section not found in data dictionary");

  DOMNodePtr pFieldNode = pFieldsNode->getFirstChildNode();
  if(!pFieldNode.get()) throw ConfigError("No fields defined");

  while(pFieldNode.get())
  {
    if(pFieldNode->getName() == "field")
    {
      DOMAttributesPtr attrs = pFieldNode->getAttributes();
      std::string name;
      if(!attrs->get("name", name))
        throw ConfigError("<field> does not have a name attribute");
      std::string number;
      if(!attrs->get("number", number))
        throw ConfigError("<field> " + name + " does not have a number attribute");
      int num = atol(number.c_str());
      std::string type;
      if(!attrs->get("type", type))
        throw ConfigError("<field> " + name + " does not have a type attribute");
      addField(num);
      addFieldType(num, XMLTypeToType(type));
      addFieldName(num, name);

      DOMNodePtr pFieldValueNode = pFieldNode->getFirstChildNode();
      while(pFieldValueNode.get())
      {
        if(pFieldValueNode->getName() == "value")
        {
          DOMAttributesPtr attrs = pFieldValueNode->getAttributes();
          std::string enumeration;
          if(!attrs->get("enum", enumeration))
            throw ConfigError("<value> does not have enum attribute in field " + name);
          addFieldValue(num, enumeration);
          std::string description;
          if(attrs->get("description", description))
            addValueName(num, enumeration, description);
        }
        RESET_AUTO_PTR(pFieldValueNode, pFieldValueNode->getNextSiblingNode());
      }
    }
    RESET_AUTO_PTR(pFieldNode, pFieldNode->getNextSiblingNode());
  }

  // HEADER
  if( type == "FIXT" || (type == "FIX" && major < "5") )
  {
    DOMNodePtr pHeaderNode = pDoc->getNode("/fix/header");
    if(!pHeaderNode.get())
      throw ConfigError("<header> section not found in data dictionary");

    DOMNodePtr pHeaderFieldNode = pHeaderNode->getFirstChildNode();
    if(!pHeaderFieldNode.get()) throw ConfigError("No header fields defined");

    while(pHeaderFieldNode.get())
    {
      if(pHeaderFieldNode->getName() == "field" || pHeaderFieldNode->getName() == "group" )
      {
        DOMAttributesPtr attrs = pHeaderFieldNode->getAttributes();
        std::string name;
        if(!attrs->get("name", name))
          throw ConfigError("<field> does not have a name attribute");
        std::string required = "false";
        attrs->get("required", required);
        addHeaderField(lookupXMLFieldNumber(pDoc.get(), name), required == "true");
      }
      if(pHeaderFieldNode->getName() == "group")
      {
        DOMAttributesPtr attrs = pHeaderFieldNode->getAttributes();
        std::string required;
        attrs->get("required", required);
        bool isRequired = (required == "Y" || required == "y");
        addXMLGroup(pDoc.get(), pHeaderFieldNode.get(), "_header_", *this, isRequired);
      }

      RESET_AUTO_PTR(pHeaderFieldNode, pHeaderFieldNode->getNextSiblingNode());
    }
  }

  // TRAILER
    if( type == "FIXT" || (type == "FIX" && major < "5") )
    {
    DOMNodePtr pTrailerNode = pDoc->getNode("/fix/trailer");
    if(!pTrailerNode.get())
      throw ConfigError("<trailer> section not found in data dictionary");

    DOMNodePtr pTrailerFieldNode = pTrailerNode->getFirstChildNode();
    if(!pTrailerFieldNode.get()) throw ConfigError("No trailer fields defined");

    while(pTrailerFieldNode.get())
    {
      if(pTrailerFieldNode->getName() == "field" || pTrailerFieldNode->getName() == "group" )
      {
        DOMAttributesPtr attrs = pTrailerFieldNode->getAttributes();
        std::string name;
        if(!attrs->get("name", name))
          throw ConfigError("<field> does not have a name attribute");
        std::string required = "false";
        attrs->get("required", required);
        addTrailerField(lookupXMLFieldNumber(pDoc.get(), name), required == "true");
      }
      if(pTrailerFieldNode->getName() == "group")
      {
        DOMAttributesPtr attrs = pTrailerFieldNode->getAttributes();
        std::string required;
        attrs->get("required", required);
        bool isRequired = (required == "Y" || required == "y");
        addXMLGroup(pDoc.get(), pTrailerFieldNode.get(), "_trailer_", *this, isRequired);
      }

      RESET_AUTO_PTR(pTrailerFieldNode, pTrailerFieldNode->getNextSiblingNode());
    }
  }

  // MSGTYPE
  DOMNodePtr pMessagesNode = pDoc->getNode("/fix/messages");
  if(!pMessagesNode.get())
    throw ConfigError("<messages> section not found in data dictionary");

  DOMNodePtr pMessageNode = pMessagesNode->getFirstChildNode();
  if(!pMessageNode.get()) throw ConfigError("No messages defined");

  while(pMessageNode.get())
  {
    if(pMessageNode->getName() == "message")
    {
      DOMAttributesPtr attrs = pMessageNode->getAttributes();
      std::string msgtype;
      if(!attrs->get("msgtype", msgtype))
        throw ConfigError("<field> does not have a name attribute");
      addMsgType(msgtype);

      std::string name;
      if(attrs->get("name", name))
        addValueName( 35, msgtype, name );

      DOMNodePtr pMessageFieldNode = pMessageNode->getFirstChildNode();
      while( pMessageFieldNode.get() )
      {
        if(pMessageFieldNode->getName() == "field"
           || pMessageFieldNode->getName() == "group")
        {
          DOMAttributesPtr attrs = pMessageFieldNode->getAttributes();
          std::string name;
          if(!attrs->get("name", name))
            throw ConfigError("<field> does not have a name attribute");
          int num = lookupXMLFieldNumber(pDoc.get(), name);
          addMsgField(msgtype, num);

          std::string required;
          if(attrs->get("required", required)
             && (required == "Y" || required == "y"))
          {
            addRequiredField(msgtype, num);
          }
        }
        else if(pMessageFieldNode->getName() == "component")
        {
          DOMAttributesPtr attrs = pMessageFieldNode->getAttributes();
          std::string required;
          attrs->get("required", required);
          bool isRequired = (required == "Y" || required == "y");
          addXMLComponentFields(pDoc.get(), pMessageFieldNode.get(),
                                msgtype, *this, isRequired);
        }
        if(pMessageFieldNode->getName() == "group")
        {
          DOMAttributesPtr attrs = pMessageFieldNode->getAttributes();
          std::string required;
          attrs->get("required", required);
          bool isRequired = (required == "Y" || required == "y");
          addXMLGroup(pDoc.get(), pMessageFieldNode.get(), msgtype, *this, isRequired);
        }
        RESET_AUTO_PTR(pMessageFieldNode,
                       pMessageFieldNode->getNextSiblingNode());
      }
    }
    RESET_AUTO_PTR(pMessageNode, pMessageNode->getNextSiblingNode());
  }
}
void FIX::DataDictionary::readFromStream ( std::istream &  stream) throw ( ConfigError )

Definition at line 221 of file DataDictionary.cpp.

{
#ifdef HAVE_LIBXML
  DOMDocumentPtr pDoc = DOMDocumentPtr(new LIBXML_DOMDocument());
#elif _MSC_VER
  DOMDocumentPtr pDoc = DOMDocumentPtr(new MSXML_DOMDocument());
#else
  DOMDocumentPtr pDoc = DOMDocumentPtr(new LIBXML_DOMDocument());
#endif

  if(!pDoc->load(stream))
    throw ConfigError("Could not parse data dictionary stream");

  readFromDocument( pDoc );
}
void FIX::DataDictionary::readFromURL ( const std::string &  url) throw ( ConfigError )

Definition at line 197 of file DataDictionary.cpp.

{
#ifdef HAVE_LIBXML
  DOMDocumentPtr pDoc = DOMDocumentPtr(new LIBXML_DOMDocument());
#elif _MSC_VER
  DOMDocumentPtr pDoc = DOMDocumentPtr(new MSXML_DOMDocument());
#else
  DOMDocumentPtr pDoc = DOMDocumentPtr(new LIBXML_DOMDocument());
#endif

  if(!pDoc->load(url))
    throw ConfigError(url + ": Could not parse data dictionary file");

  try
  {
    readFromDocument( pDoc );
  }
  catch( ConfigError& e )
  {
    throw ConfigError( url + ": " + e.what() );
  }
}
void FIX::DataDictionary::readLibXml ( const std::string &  ) [private]

Read XML file using libXML.

void FIX::DataDictionary::readMSXML ( const std::string &  ) [private]
void FIX::DataDictionary::readMSXMLDOM ( const std::string &  ) [private]

Read XML file using MSXML.

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

Definition at line 86 of file DataDictionary.h.

References m_beginString, and m_hasVersion.

Referenced by addGroup().

  {
    m_beginString = beginString;
    m_hasVersion = true;
  }
bool FIX::DataDictionary::shouldCheckTag ( const FieldBase field) const [inline, private]

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

Definition at line 331 of file DataDictionary.h.

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

Referenced by iterate().

  {
    if( !m_checkUserDefinedFields && field.getField() >= FIELD::UserMin )
      return false;
    else
      return true;
  }
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 FIX::Session::next().

{  
  const Header& header = message.getHeader();
  const BeginString& beginString = FIELD_GET_REF( header, BeginString );
  const MsgType& msgType = FIELD_GET_REF( header, MsgType );
  if ( pSessionDD != 0 && pSessionDD->m_hasVersion )
  {
    if( pSessionDD->getVersion() != beginString )
    {
      throw UnsupportedVersion();
    }
  }

  int field = 0;
  if( (pSessionDD !=0 && pSessionDD->m_checkFieldsOutOfOrder) || 
      (pAppDD != 0 && pAppDD->m_checkFieldsOutOfOrder) )
  {
    if ( !message.hasValidStructure(field) )
      throw TagOutOfOrder(field);
  }

  if ( pAppDD != 0 && pAppDD->m_hasVersion )
  {
    pAppDD->checkMsgType( msgType );
    pAppDD->checkHasRequired( message.getHeader(), message, message.getTrailer(), msgType );
  }

  if( pSessionDD != 0 )
  {
    pSessionDD->iterate( message.getHeader(), msgType );
    pSessionDD->iterate( message.getTrailer(), msgType );
  }

  if( pAppDD != 0 )
  {
    pAppDD->iterate( message, msgType );
  }
}
void FIX::DataDictionary::validate ( const Message message) const throw ( FIX::Exception ) [inline]

Definition at line 312 of file DataDictionary.h.

References validate().

Referenced by validate().

  { validate( message, false ); }
void FIX::DataDictionary::validate ( const Message message,
bool  bodyOnly 
) const throw ( FIX::Exception ) [inline]

Definition at line 314 of file DataDictionary.h.

References validate().

Referenced by validate().

  { validate( message, bodyOnly ? (DataDictionary*)0 : this, this ); }
TYPE::Type FIX::DataDictionary::XMLTypeToType ( const std::string &  xmlType) const [private]

Definition at line 601 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::UtcTimeOnly, and FIX::TYPE::UtcTimeStamp.

{
  if ( m_beginString < "FIX.4.2" && type == "CHAR" )
    return TYPE::String;

  if ( type == "STRING" ) return TYPE::String;
  if ( type == "CHAR" ) return TYPE::Char;
  if ( type == "PRICE" ) return TYPE::Price;
  if ( type == "INT" ) return TYPE::Int;
  if ( type == "AMT" ) return TYPE::Amt;
  if ( type == "QTY" ) return TYPE::Qty;
  if ( type == "CURRENCY" ) return TYPE::Currency;
  if ( type == "MULTIPLEVALUESTRING" ) return TYPE::MultipleValueString;
  if ( type == "MULTIPLESTRINGVALUE" ) return TYPE::MultipleStringValue;
  if ( type == "MULTIPLECHARVALUE" ) return TYPE::MultipleCharValue;
  if ( type == "EXCHANGE" ) return TYPE::Exchange;
  if ( type == "UTCTIMESTAMP" ) return TYPE::UtcTimeStamp;
  if ( type == "BOOLEAN" ) return TYPE::Boolean;
  if ( type == "LOCALMKTDATE" ) return TYPE::LocalMktDate;
  if ( type == "DATA" ) return TYPE::Data;
  if ( type == "FLOAT" ) return TYPE::Float;
  if ( type == "PRICEOFFSET" ) return TYPE::PriceOffset;
  if ( type == "MONTHYEAR" ) return TYPE::MonthYear;
  if ( type == "DAYOFMONTH" ) return TYPE::DayOfMonth;
  if ( type == "UTCDATE" ) return TYPE::UtcDate;
  if ( type == "UTCDATEONLY" ) return TYPE::UtcDateOnly;
  if ( type == "UTCTIMEONLY" ) return TYPE::UtcTimeOnly;
  if ( type == "NUMINGROUP" ) return TYPE::NumInGroup;
  if ( type == "PERCENTAGE" ) return TYPE::Percentage;
  if ( type == "SEQNUM" ) return TYPE::SeqNum;
  if ( type == "LENGTH" ) return TYPE::Length;
  if ( type == "COUNTRY" ) return TYPE::Country;
  if ( type == "TIME" ) return TYPE::UtcTimeStamp;
  return TYPE::Unknown;
}

Member Data Documentation

BeginString FIX::DataDictionary::m_beginString [private]

Definition at line 526 of file DataDictionary.h.

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

Definition at line 524 of file DataDictionary.h.

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

Definition at line 523 of file DataDictionary.h.

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

Definition at line 525 of file DataDictionary.h.

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

Definition at line 541 of file DataDictionary.h.

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

Definition at line 537 of file DataDictionary.h.

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

Definition at line 530 of file DataDictionary.h.

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

Definition at line 535 of file DataDictionary.h.

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

Definition at line 536 of file DataDictionary.h.

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

Definition at line 540 of file DataDictionary.h.

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

Definition at line 522 of file DataDictionary.h.

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

Definition at line 533 of file DataDictionary.h.

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

Definition at line 527 of file DataDictionary.h.

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

Definition at line 529 of file DataDictionary.h.

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

Definition at line 538 of file DataDictionary.h.

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

Definition at line 531 of file DataDictionary.h.

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

Definition at line 532 of file DataDictionary.h.

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

Definition at line 528 of file DataDictionary.h.

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

Definition at line 534 of file DataDictionary.h.

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

Definition at line 539 of file DataDictionary.h.

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


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

Generated on Mon Jun 23 2014 23:49:39 for QuickFIX by doxygen 1.7.6.1 written by Dimitri van Heesch, © 1997-2001