/// <summary>
/// Aidan Chisholm IRESS 23/10/2017
/// Added to overload Message constrcutore to bypass message validation / re-ordering of body tags
/// </summary>
/// <param name="msgstr"></param>
/// <param name="sessionDataDictionary"></param>
/// <param name="appDD"></param>
/// <param name="validateLengthAndChecksum"></param>
/// <param name="ignoreBody"></param>
public Message(string msgstr, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD, bool validateLengthAndChecksum, bool ignoreBody)
: this()
{
FromStringHeader(msgstr);
FromString(msgstr, validateLengthAndChecksum, sessionDataDictionary, appDD, null, ignoreBody);
}
protected DataDictionary.DataDictionary createDataDictionary(SessionID sessionID, QuickFix.Dictionary settings, string settingsKey, string beginString)
{
DataDictionary.DataDictionary dd;
string path;
if (settings.Has(settingsKey))
path = settings.GetString(settingsKey);
else
path = beginString.Replace(".", "") + ".xml";
if (!dictionariesByPath_.TryGetValue(path, out dd))
{
dd = new DataDictionary.DataDictionary(path);
dictionariesByPath_[path] = dd;
}
DataDictionary.DataDictionary ddCopy = new DataDictionary.DataDictionary(dd);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER))
ddCopy.CheckFieldsOutOfOrder = settings.GetBool(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES))
ddCopy.CheckFieldsHaveValues = settings.GetBool(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES);
if (settings.Has(SessionSettings.VALIDATE_USER_DEFINED_FIELDS))
ddCopy.CheckUserDefinedFields = settings.GetBool(SessionSettings.VALIDATE_USER_DEFINED_FIELDS);
if (settings.Has(SessionSettings.ALLOW_UNKNOWN_MSG_FIELDS))
ddCopy.AllowUnknownMessageFields = settings.GetBool(SessionSettings.ALLOW_UNKNOWN_MSG_FIELDS);
return ddCopy;
}
protected DataDictionary.DataDictionary createDataDictionary(SessionID sessionID, QuickFix.Dictionary settings, string settingsKey)
{
DataDictionary.DataDictionary dd;
string path = settings.GetString(settingsKey);
if (!dictionariesByPath_.TryGetValue(path, out dd))
{
dd = new DataDictionary.DataDictionary(path);
dictionariesByPath_[path] = dd;
}
DataDictionary.DataDictionary ddCopy = new DataDictionary.DataDictionary(dd);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER))
{
ddCopy.CheckFieldsOutOfOrder = settings.GetBool(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER);
}
if (settings.Has(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES))
{
ddCopy.CheckFieldsHaveValues = settings.GetBool(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES);
}
if (settings.Has(SessionSettings.VALIDATE_USER_DEFINED_FIELDS))
{
ddCopy.CheckUserDefinedFields = settings.GetBool(SessionSettings.VALIDATE_USER_DEFINED_FIELDS);
}
return(ddCopy);
}
public static void Validate(Message message, DataDictionary sessionDataDict, DataDictionary appDataDict, string beginString, string msgType)
{
bool bodyOnly = (null == sessionDataDict);
if ((null != sessionDataDict) && (null != sessionDataDict.Version))
if (!sessionDataDict.Version.Equals(beginString))
throw new UnsupportedVersion();
if (((null != sessionDataDict) && sessionDataDict.CheckFieldsOutOfOrder) || ((null != appDataDict) && appDataDict.CheckFieldsOutOfOrder))
{
int field;
if (!message.HasValidStructure(out field))
throw new TagOutOfOrder(field);
}
if ((null != appDataDict) && (null != appDataDict.Version))
{
appDataDict.CheckMsgType(msgType);
appDataDict.CheckHasRequired(message, msgType);
}
if (!bodyOnly)
{
sessionDataDict.Iterate(message.Header, msgType);
sessionDataDict.Iterate(message.Trailer, msgType);
}
appDataDict.Iterate(message, msgType);
}
private static string FieldMapToXML(DataDictionary.DataDictionary dd, FieldMap fields, int space)
{
StringBuilder s = new StringBuilder();
string name = string.Empty;
// fields
foreach (var f in fields)
{
s.Append("<field ");
if ((dd != null) && (dd.FieldsByTag.ContainsKey(f.Key)))
{
s.Append("name=\"" + dd.FieldsByTag[f.Key].Name + "\" ");
}
s.Append("number=\"" + f.Key.ToString() + "\">");
s.Append("<![CDATA[" + f.Value.ToString() + "]]>");
s.Append("</field>");
}
// now groups
List <int> groupTags = fields.GetGroupTags();
foreach (int groupTag in groupTags)
{
for (int counter = 1; counter <= fields.GroupCount(groupTag); counter++)
{
s.Append("<group>");
s.Append(FieldMapToXML(dd, fields.GetGroup(counter, groupTag), space + 1));
s.Append("</group>");
}
}
return(s.ToString());
}
protected void ProcessFixTDataDictionaries(SessionID sessionID, Dictionary settings, DataDictionaryProvider provider)
{
provider.AddTransportDataDictionary(sessionID.BeginString, createDataDictionary(sessionID, settings, SessionSettings.TRANSPORT_DATA_DICTIONARY, sessionID.BeginString));
foreach (KeyValuePair <string, string> setting in settings)
{
if (setting.Key.StartsWith(SessionSettings.APP_DATA_DICTIONARY, System.StringComparison.CurrentCultureIgnoreCase))
{
if (setting.Key.Equals(SessionSettings.APP_DATA_DICTIONARY, System.StringComparison.CurrentCultureIgnoreCase))
{
Fields.ApplVerID applVerId = Message.GetApplVerID(settings.GetString(SessionSettings.DEFAULT_APPLVERID));
DataDictionary.DataDictionary dd = createDataDictionary(sessionID, settings, SessionSettings.APP_DATA_DICTIONARY, sessionID.BeginString);
provider.AddApplicationDataDictionary(applVerId.Obj, dd);
}
else
{
int offset = setting.Key.IndexOf(".");
if (offset == -1)
{
throw new System.ArgumentException(string.Format("Malformed {0} : {1}", SessionSettings.APP_DATA_DICTIONARY, setting.Key));
}
string beginStringQualifier = setting.Key.Substring(offset);
DataDictionary.DataDictionary dd = createDataDictionary(sessionID, settings, setting.Key, beginStringQualifier);
provider.AddApplicationDataDictionary(Message.GetApplVerID(beginStringQualifier).Obj, dd);
}
}
}
}
public static void LoadDictionary(string sFIXDictionary)
{
if (!string.IsNullOrEmpty(sFIXDictionary))
{
dataDictionary = new FIXDictionary.DataDictionary();
dataDictionary.Load(sFIXDictionary);
}
}
public static bool IsTrailerField(int tag, DataDictionary.DataDictionary dd)
{
if (IsTrailerField(tag))
{
return(true);
}
if (null != dd)
{
return(dd.IsTrailerField(tag));
}
return(false);
}
public Message(string msgstr, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD, bool validate)
: this()
{
FromStringHeader(msgstr);
if (IsAdmin())
{
FromString(msgstr, validate, sessionDataDictionary, sessionDataDictionary, null);
}
else
{
FromString(msgstr, validate, sessionDataDictionary, appDD, null);
}
}
public static StringField ExtractField(string msgstr, ref int pos, DataDictionary.DataDictionary sessionDD, DataDictionary.DataDictionary appDD)
{
try
{
int tagend = msgstr.IndexOf('=', pos);
int tag = Convert.ToInt32(msgstr.Substring(pos, tagend - pos));
pos = tagend + 1;
int fieldvalend = msgstr.IndexOf((char)1, pos);
StringField field = new StringField(tag, msgstr.Substring(pos, fieldvalend - pos));
/*
* TODO data dict stuff
* if (((null != sessionDD) && sessionDD.IsDataField(field.Tag)) || ((null != appDD) && appDD.IsDataField(field.Tag)))
* {
* string fieldLength = "";
* // Assume length field is 1 less
* int lenField = field.Tag - 1;
* // Special case for Signature which violates above assumption
* if (Tags.Signature.Equals(field.Tag))
* lenField = Tags.SignatureLength;
*
* if ((null != group) && group.isSetField(lenField))
* {
* fieldLength = group.GetField(lenField);
* soh = equalSign + 1 + atol(fieldLength.c_str());
* }
* else if (isSetField(lenField))
* {
* fieldLength = getField(lenField);
* soh = equalSign + 1 + atol(fieldLength.c_str());
* }
* }
*/
pos = fieldvalend + 1;
return(field);
}
catch (System.ArgumentOutOfRangeException e)
{
throw new MessageParseError("Error at position (" + pos + ") while parsing msg (" + msgstr + ")", e);
}
catch (System.OverflowException e)
{
throw new MessageParseError("Error at position (" + pos + ") while parsing msg (" + msgstr + ")", e);
}
catch (System.FormatException e)
{
throw new MessageParseError("Error at position (" + pos + ") while parsing msg (" + msgstr + ")", e);
}
}
static void Main(string[] args)
{
DataDictionary dd = new QuickFix.DataDictionary.DataDictionary("fix\\FIX50SP2.xml");
StreamReader file = new StreamReader(@"C:\secdef.dat");
int count = 0; string line;
while (((line = file.ReadLine()) != null && count++ < MAX_LINES))
{
QuickFix.FIX50.SecurityDefinition secDef = new QuickFix.FIX50.SecurityDefinition();
secDef.FromString(line, false, dd, dd);
Console.WriteLine(secDef.SecurityDesc);
}
file.Close();
}
internal MessageBuilder(
string msgStr,
bool validateLengthAndChecksum,
DataDictionary.DataDictionary sessionDD,
DataDictionary.DataDictionary appDD,
IMessageFactory msgFactory)
{
_msgStr = msgStr;
_validateLengthAndChecksum = validateLengthAndChecksum;
_sessionDD = sessionDD;
_appDD = appDD;
_msgFactory = msgFactory;
_msgType = Message.IdentifyType(_msgStr);
_beginString = Message.ExtractBeginString(_msgStr);
}
internal MessageBuilder(
string msgStr,
bool validateLengthAndChecksum,
DataDictionary.DataDictionary sessionDD,
DataDictionary.DataDictionary appDD,
IMessageFactory msgFactory)
{
_msgStr = msgStr;
_validateLengthAndChecksum = validateLengthAndChecksum;
_sessionDD = sessionDD;
_appDD = appDD;
_msgFactory = msgFactory;
_msgType = Message.IdentifyType(_msgStr);
_beginString = Message.ExtractBeginString(_msgStr);
}
public static FIXConverter CreateInstance(string sFIXDictionary)
{
if (Instance == null)
{
Instance = new FIXConverter();
if (!string.IsNullOrEmpty(sFIXDictionary))
{
dataDictionary = new FIXDictionary.DataDictionary();
dataDictionary.Load(sFIXDictionary);
}
fixClasses = FIXClassesInfo.CreateInstance();
fixClasses.LoadQuickFIXTypesInfo("QuickFix.FIX");
}
return(Instance);
}
/// <summary>
/// Copy a data dictionary
/// </summary>
/// <param name="src">the source dictionary that will be copied into this dictionary</param>
public DataDictionary(DataDictionary src)
: this()
{
this.Messages = src.Messages;
this.FieldsByName = src.FieldsByName;
this.FieldsByTag = src.FieldsByTag;
if (null != src.MajorVersion)
this.MajorVersion = string.Copy(src.MajorVersion);
if (null != src.MinorVersion)
this.MinorVersion = string.Copy(src.MinorVersion);
if (null != src.Version)
this.Version = string.Copy(src.Version);
this.CheckFieldsHaveValues = src.CheckFieldsHaveValues;
this.CheckFieldsOutOfOrder = src.CheckFieldsOutOfOrder;
this.CheckUserDefinedFields = src.CheckUserDefinedFields;
this.Header = src.Header;
this.Trailer = src.Trailer;
}
void LoadDictionaryAndFields()
{
InsightCalculator.InsightsDatabase =
JsonConvert.DeserializeObject <InsightsDatabase>(
File.ReadAllText(Path.Combine(Application.StartupPath, "insights.json")));
dd = new QuickFix.DataDictionary.DataDictionary();
Stream stream = new FileStream(Path.Combine(Application.StartupPath, "spec", "FIX42.xml"), FileMode.Open, FileAccess.Read);
dd.Load(stream);
foreach (var ddField in dd.FieldsByTag)
{
var c = new ComboBoxItem();
c.Text = ddField.Value.Name + $" ({ddField.Key})";
c.Tag = ddField.Value;
_fieldsBoxItems.Add(ddField.Key, c);
FieldCol.Items.Add(c);
}
}
public StringField ExtractFieldCustom(string msgstr, ref int pos, DataDictionary.DataDictionary sessionDD, DataDictionary.DataDictionary appDD)
{
int equalsOffSet = 0;
int tag = 0;
int sohOffSet = 0;
try
{
equalsOffSet = msgstr.IndexOf("=", pos);
tag = Convert.ToInt32(msgstr.Substring(pos, equalsOffSet - pos));
sohOffSet = msgstr.IndexOf("\u0001", equalsOffSet + 1);
// Assume length field is 1 less
int tagLengthField = tag - 1;
// Special case for Signature which violates above assumption
//if (Tags.Signature.Equals(tag))
// tagLengthField = Tags.SignatureLength;
if (tag == Tags.RawData && tagLengthField == Tags.RawDataLength)
{
int fieldLength = Convert.ToInt32(this.GetField(tagLengthField));
sohOffSet = equalsOffSet + 1 + fieldLength;
}
pos = sohOffSet + 1;
return(new StringField(tag, msgstr.Substring(equalsOffSet + 1, sohOffSet - (equalsOffSet + 1))));
}
catch (System.ArgumentOutOfRangeException e)
{
throw new MessageParseError("1.Custom - Error at position (" + pos + ") while parsing msg (" + msgstr + ")", e);
}
catch (System.OverflowException e)
{
throw new MessageParseError("2.Custom - Error at position (" + pos + ") while parsing msg (" + msgstr + ")", e);
}
catch (System.FormatException e)
{
throw new MessageParseError("3.Custom - Error at position (" + pos + ") while parsing msg (" + msgstr + ") equalsOffSet(" + equalsOffSet + ") pos(" + pos + ") sohOffSet(" + sohOffSet + ") parse(" + msgstr.Substring(pos, equalsOffSet - pos) + ")", e);
}
}
public Message TryParseMessage(string line, IMessageFactory messageFactory, QuickFix.DataDictionary.DataDictionary dd)
{
Message m = null;
int pos = 0;
try
{
StringField protocol = Message.ExtractField(line, ref pos);
StringField t = Message.ExtractField(line, ref pos);
StringField type = Message.ExtractField(line, ref pos);
m = messageFactory.Create(protocol.getValue(), type.getValue());
while (pos < line.Length)
{
m.SetField(Message.ExtractField(line, ref pos));
}
m.FromString(line, false, dd, dd, messageFactory);
}
catch
{
}
return(m);
}
public Message(string msgstr, DataDictionary.DataDictionary dataDictionary, bool validate)
: this()
{
FromString(msgstr, validate, dataDictionary, dataDictionary, null);
}
/// <summary>
/// Constructs a group and stores it in this Message object
/// </summary>
/// <param name="grpNoFld">the group's counter field</param>
/// <param name="msgstr">full message string</param>
/// <param name="pos">starting character position of group</param>
/// <param name="fieldMap">full message as FieldMap</param>
/// <param name="dd">group definition structure from dd</param>
/// <param name="sessionDataDictionary"></param>
/// <param name="appDD"></param>
/// <param name="msgFactory">if null, then this method will use the generic Group class constructor</param>
/// <returns></returns>
protected int SetGroup(
StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd,
DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory)
{
int grpEntryDelimiterTag = dd.Delim;
int grpPos = pos;
Group grp = null; // the group entry being constructed
while (pos < msgstr.Length)
{
grpPos = pos;
StringField f = ExtractField(msgstr, ref pos, sessionDataDictionary, appDD);
if (f.Tag == grpEntryDelimiterTag)
{
// This is the start of a group entry.
if (grp != null)
{
// We were already building an entry, so the delimiter means it's done.
fieldMap.AddGroup(grp, false);
grp = null; // prepare for new Group
}
// Create a new group!
if (msgFactory != null)
{
grp = msgFactory.Create(Message.ExtractBeginString(msgstr), Message.GetMsgType(msgstr), grpNoFld.Tag);
}
//If above failed (shouldn't ever happen), just use a generic Group.
if (grp == null)
{
grp = new Group(grpNoFld.Tag, grpEntryDelimiterTag);
}
}
else if (!dd.IsField(f.Tag))
{
// This field is not in the group, thus the repeating group is done.
if (grp != null)
{
fieldMap.AddGroup(grp, false);
}
return(grpPos);
}
if (grp == null)
{
// This means we got into the group's fields without finding a delimiter tag.
throw new GroupDelimiterTagException(grpNoFld.Tag, grpEntryDelimiterTag);
}
// f is just a field in our group entry. Add it and iterate again.
grp.SetField(f);
if (dd.IsGroup(f.Tag))
{
// f is a counter for a nested group. Recurse!
pos = SetGroup(f, msgstr, pos, grp, dd.GetGroupSpec(f.Tag), sessionDataDictionary, appDD, msgFactory);
}
}
return(grpPos);
}
protected int SetGroup(StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd,
DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD)
{
return(SetGroup(grpNoFld, msgstr, pos, fieldMap, dd, sessionDataDictionary, appDD, null));
}
/// <summary>
/// Creates a Message from a FIX string
/// </summary>
/// <param name="msgstr"></param>
/// <param name="validate"></param>
/// <param name="sessionDD"></param>
/// <param name="appDD"></param>
/// <param name="msgFactory">If null, any groups will be constructed as generic Group objects</param>
/// <param name="ignoreBody">(default false) if true, ignores all non-header non-trailer fields.
/// Intended for callers that only need rejection-related information from the header.
/// </param>
public void FromString(string msgstr, bool validate,
DataDictionary.DataDictionary sessionDD, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory,
bool ignoreBody)
{
Clear();
string msgType = "";
bool expectingHeader = true;
bool expectingBody = true;
int count = 0;
int pos = 0;
DataDictionary.IFieldMapSpec msgMap = null;
while (pos < msgstr.Length)
{
StringField f = ExtractField(msgstr, ref pos, sessionDD, appDD);
if (validate && (count < 3) && (Header.HEADER_FIELD_ORDER[count++] != f.Tag))
{
throw new InvalidMessage("Header fields out of order");
}
if (IsHeaderField(f.Tag, sessionDD))
{
if (!expectingHeader)
{
if (0 == field_)
{
field_ = f.Tag;
}
validStructure_ = false;
}
if (Tags.MsgType.Equals(f.Tag))
{
msgType = string.Copy(f.Obj);
if (appDD != null)
{
msgMap = appDD.GetMapForMessage(msgType);
}
}
if (!this.Header.SetField(f, false))
{
this.Header.RepeatedTags.Add(f);
}
if ((null != sessionDD) && sessionDD.Header.IsGroup(f.Tag))
{
pos = SetGroup(f, msgstr, pos, this.Header, sessionDD.Header.GetGroupSpec(f.Tag), sessionDD, appDD, msgFactory);
}
}
else if (IsTrailerField(f.Tag, sessionDD))
{
expectingHeader = false;
expectingBody = false;
if (!this.Trailer.SetField(f, false))
{
this.Trailer.RepeatedTags.Add(f);
}
if ((null != sessionDD) && sessionDD.Trailer.IsGroup(f.Tag))
{
pos = SetGroup(f, msgstr, pos, this.Trailer, sessionDD.Trailer.GetGroup(f.Tag), sessionDD, appDD, msgFactory);
}
}
else if (ignoreBody == false)
{
if (!expectingBody)
{
if (0 == field_)
{
field_ = f.Tag;
}
validStructure_ = false;
}
expectingHeader = false;
if (!SetField(f, false))
{
this.RepeatedTags.Add(f);
}
if ((null != msgMap) && (msgMap.IsGroup(f.Tag)))
{
pos = SetGroup(f, msgstr, pos, this, msgMap.GetGroupSpec(f.Tag), sessionDD, appDD, msgFactory);
}
}
}
if (validate)
{
Validate();
}
}
public Message(string msgstr, DataDictionary.DataDictionary dataDictionary, bool validate)
: this(msgstr, dataDictionary, validate, Encoding.UTF8)
{
}
public void AddTransportDataDictionary(string beginString, DataDictionary.DataDictionary dataDictionary)
{
transportDataDictionaries_[beginString] = dataDictionary;
}
/// TODO need to make deeper copy?
public DataDictionaryProvider(DataDictionaryProvider src)
{
transportDataDictionaries_ = new Dictionary<string, DataDictionary.DataDictionary>(src.transportDataDictionaries_);
applicationDataDictionaries_ = new Dictionary<string, DataDictionary.DataDictionary>(src.applicationDataDictionaries_);
emptyDataDictionary_ = new DataDictionary.DataDictionary(src.emptyDataDictionary_);
}
protected bool InitializeXML(string url)
{
try
{
DataDictionary.DataDictionary p = new DataDictionary.DataDictionary(url);
dataDictionary_ = p;
return true;
}
catch
{
return false;
}
}
protected DataDictionary.DataDictionary createDataDictionary(SessionID sessionID, QuickFix.Dictionary settings, string settingsKey, string beginString)
{
DataDictionary.DataDictionary dd;
string path;
if (settings.Has(settingsKey))
path = settings.GetString(settingsKey);
else
path = beginString.Replace("\\.", "") + ".xml";
if (!dictionariesByPath_.TryGetValue(path, out dd))
{
dd = new DataDictionary.DataDictionary(path);
dictionariesByPath_[path] = dd;
}
DataDictionary.DataDictionary ddCopy = new DataDictionary.DataDictionary(dd);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER))
ddCopy.CheckFieldsOutOfOrder = settings.GetBool(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES))
ddCopy.CheckFieldsHaveValues = settings.GetBool(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES);
if (settings.Has(SessionSettings.VALIDATE_USER_DEFINED_FIELDS))
ddCopy.CheckUserDefinedFields = settings.GetBool(SessionSettings.VALIDATE_USER_DEFINED_FIELDS);
return ddCopy;
}
/// <summary>
/// Creates a Message from a FIX string
/// </summary>
/// <param name="msgstr"></param>
/// <param name="validate"></param>
/// <param name="sessionDD"></param>
/// <param name="appDD"></param>
/// <param name="msgFactory">If null, any groups will be constructed as generic Group objects</param>
/// <param name="ignoreBody">(default false) if true, ignores all non-header non-trailer fields.
/// Intended for callers that only need rejection-related information from the header.
/// </param>
public void FromString(string msgstr, bool validate,
DataDictionary.DataDictionary sessionDD, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory,
bool ignoreBody)
{
Clear();
string msgType = "";
bool expectingHeader = true;
bool expectingBody = true;
int count = 0;
int pos = 0;
DataDictionary.IFieldMapSpec msgMap = null;
while (pos < msgstr.Length)
{
StringField f = ExtractField(msgstr, ref pos, sessionDD, appDD);
if (validate && (count < 3) && (Header.HEADER_FIELD_ORDER[count++] != f.Tag))
{
throw new InvalidMessage("Header fields out of order");
}
if (IsHeaderField(f.Tag, sessionDD))
{
if (!expectingHeader)
{
if (0 == field_)
{
field_ = f.Tag;
}
validStructure_ = false;
}
if (Tags.MsgType.Equals(f.Tag))
{
msgType = string.Copy(f.Obj);
if (appDD != null)
{
msgMap = appDD.GetMapForMessage(msgType);
}
}
if (!this.Header.SetField(f, false))
{
this.Header.RepeatedTags.Add(f);
}
if ((null != sessionDD) && sessionDD.Header.IsGroup(f.Tag))
{
pos = SetGroup(f, msgstr, pos, this.Header, sessionDD.Header.GetGroupSpec(f.Tag), sessionDD, appDD, msgFactory);
}
}
else if (IsTrailerField(f.Tag, sessionDD))
{
expectingHeader = false;
expectingBody = false;
if (!this.Trailer.SetField(f, false))
{
this.Trailer.RepeatedTags.Add(f);
}
if ((null != sessionDD) && sessionDD.Trailer.IsGroup(f.Tag))
{
pos = SetGroup(f, msgstr, pos, this.Trailer, sessionDD.Trailer.GetGroup(f.Tag), sessionDD, appDD, msgFactory);
}
}
else if (ignoreBody == false)
{
if (!expectingBody)
{
if (0 == field_)
{
field_ = f.Tag;
}
validStructure_ = false;
}
expectingHeader = false;
if (!SetField(f, false))
{
this.RepeatedTags.Add(f);
}
if ((null != msgMap) && (msgMap.IsGroup(f.Tag)))
{
pos = SetGroup(f, msgstr, pos, this, msgMap.GetGroupSpec(f.Tag), sessionDD, appDD, msgFactory);
}
}
// Aidan Chisholm IRESS 23/10/2017
// Bypassing body validation so need to keep fields in original order due to FieldMap re-ordering combined with unknown tags/repeating-groups
else if (ignoreBody == true)
{
if (!expectingBody)
{
if (0 == field_)
{
field_ = f.Tag;
}
validStructure_ = false;
}
expectingHeader = false;
SetUnorderedField(f);
//Console.WriteLine("{0} - {1}", f.Tag.ToString(), f.ToString());
}
}
if (validate)
{
Validate();
}
}
/// <summary>
/// Constructs a group and stores it in this Message object
/// </summary>
/// <param name="grpNoFld"></param>
/// <param name="msgstr"></param>
/// <param name="pos"></param>
/// <param name="fieldMap"></param>
/// <param name="dd"></param>
/// <param name="sessionDataDictionary"></param>
/// <param name="appDD"></param>
/// <param name="msgFactory">if this is null, then this method will use the generic Group class constructor</param>
/// <returns></returns>
protected int SetGroup(StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory)
{
int delim = dd.Delim;
int grpPos = pos;
Group grp = null;
while (pos < msgstr.Length)
{
grpPos = pos;
StringField f = ExtractField(msgstr, ref pos, sessionDataDictionary, appDD);
if (f.Tag == delim)
{
if (grp != null)
{
fieldMap.AddGroup(grp, false);
}
if (msgFactory != null)
{
grp = msgFactory.Create(Message.ExtractBeginString(msgstr), Message.GetMsgType(msgstr), grpNoFld.Tag);
}
//If above failed, just use a generic Group.
if (grp == null)
{
grp = new Group(grpNoFld.Tag, delim);
}
}
else if (!dd.IsField(f.Tag))
{
if (grp != null)
{
fieldMap.AddGroup(grp, false);
}
return(grpPos);
}
grp.SetField(f);
if (dd.IsGroup(f.Tag))
{
pos = SetGroup(f, msgstr, pos, grp, dd.GetGroupSpec(f.Tag), sessionDataDictionary, appDD, msgFactory);
}
}
return(grpPos);
}
public Message(string msgstr, DataDictionary.DataDictionary sessionDataDictionary,
DataDictionary.DataDictionary appDD, bool validate)
: this(msgstr, sessionDataDictionary, appDD, validate, Encoding.UTF8)
{
}
protected int SetGroup(StringField grpNoFld, string msgstr, int pos, FieldMap fieldMap, DataDictionary.IGroupSpec dd, DataDictionary.DataDictionary sessionDataDictionary, DataDictionary.DataDictionary appDD)
{
int delim = dd.Delim;
int grpPos = pos;
Group grp = null;
while (pos < msgstr.Length)
{
grpPos = pos;
StringField f = ExtractField(msgstr, ref pos, sessionDataDictionary, appDD);
if (f.Tag == delim)
{
if (grp != null)
{
fieldMap.AddGroup(grp);
}
grp = new Group(grpNoFld.Tag, delim);
}
else if (!dd.IsField(f.Tag))
{
if (grp != null)
{
fieldMap.AddGroup(grp);
}
return(grpPos);
}
grp.SetField(f);
if (dd.IsGroup(f.Tag))
{
pos = SetGroup(f, msgstr, pos, grp, dd.GetGroupSpec(f.Tag), sessionDataDictionary, appDD);
}
}
return(grpPos);
}
private DataDictionary.DataDictionary LoadDataDictionaryFromStream(Dictionary settings, Stream dictionaryStream)
{
DataDictionary.DataDictionary dd;
string path = settings.GetString(SessionSettings.DATA_DICTIONARY_STREAM);
if (!dictionariesByPath_.TryGetValue(path, out dd))
{
dd = new DataDictionary.DataDictionary(dictionaryStream);
dictionariesByPath_[path] = dd;
}
DataDictionary.DataDictionary ddCopy = new DataDictionary.DataDictionary(dd);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER))
ddCopy.CheckFieldsOutOfOrder = settings.GetBool(SessionSettings.VALIDATE_FIELDS_OUT_OF_ORDER);
if (settings.Has(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES))
ddCopy.CheckFieldsHaveValues = settings.GetBool(SessionSettings.VALIDATE_FIELDS_HAVE_VALUES);
if (settings.Has(SessionSettings.VALIDATE_USER_DEFINED_FIELDS))
ddCopy.CheckUserDefinedFields = settings.GetBool(SessionSettings.VALIDATE_USER_DEFINED_FIELDS);
return ddCopy;
}
public DataDictionaryProvider()
{
transportDataDictionaries_ = new Dictionary<string, DataDictionary.DataDictionary>();
applicationDataDictionaries_ = new Dictionary<string, DataDictionary.DataDictionary>();
emptyDataDictionary_ = new DataDictionary.DataDictionary();
}
/// <summary>
/// Creates a Message from a FIX string
/// </summary>
/// <param name="msgstr"></param>
/// <param name="validate"></param>
/// <param name="sessionDD"></param>
/// <param name="appDD"></param>
public void FromString(string msgstr, bool validate, DataDictionary.DataDictionary sessionDD, DataDictionary.DataDictionary appDD)
{
FromString(msgstr, validate, sessionDD, appDD, null);
}
public void AddApplicationDataDictionary(string applVerID, DataDictionary.DataDictionary dataDictionary)
{
applicationDataDictionaries_[applVerID] = dataDictionary;
}
/// <summary>
/// Create a Message from a FIX string
/// </summary>
/// <param name="msgstr"></param>
/// <param name="validate"></param>
/// <param name="sessionDD"></param>
/// <param name="appDD"></param>
/// <param name="msgFactory">If null, any groups will be constructed as generic Group objects</param>
public void FromString(string msgstr, bool validate,
DataDictionary.DataDictionary sessionDD, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory)
{
FromString(msgstr, validate, sessionDD, appDD, msgFactory, false);
}
protected void ProcessFixDataDictionary(SessionID sessionID, Dictionary settings, DataDictionaryProvider provider)
{
DataDictionary.DataDictionary dataDictionary = createDataDictionary(sessionID, settings, SessionSettings.DATA_DICTIONARY, sessionID.BeginString);
provider.AddTransportDataDictionary(sessionID.BeginString, dataDictionary);
provider.AddApplicationDataDictionary(FixValues.ApplVerID.FromBeginString(sessionID.BeginString), dataDictionary);
}
public void FromString(string msgstr, bool validate,
DataDictionary.DataDictionary sessionDD, DataDictionary.DataDictionary appDD, IMessageFactory msgFactory,
bool ignoreBody)
{
FromString(msgstr, validate, sessionDD, appDD, msgFactory, false, Encoding.UTF8);
}
