public override Field Parse(System.Xml.XmlElement fieldNode, bool optional, ParsingContext context)
{
Operator.Operator operator_Renamed = Operator.Operator.NONE;
string defaultValue = null;
string key = null;
string ns = "";
System.Xml.XmlElement operatorElement = GetOperatorElement(fieldNode);
if (operatorElement != null)
{
if (operatorElement.HasAttribute("value"))
defaultValue = operatorElement.GetAttribute("value");
operator_Renamed = Operator.Operator.GetOperator(operatorElement.Name);
if (operatorElement.HasAttribute("key"))
key = operatorElement.GetAttribute("key");
if (operatorElement.HasAttribute("ns"))
ns = operatorElement.GetAttribute("ns");
if (operatorElement.HasAttribute("dictionary"))
context.Dictionary = operatorElement.GetAttribute("dictionary");
}
FASTType type = GetType(fieldNode, context);
var scalar = new Scalar(GetName(fieldNode, context), type, operator_Renamed, type.GetValue(defaultValue), optional);
if (fieldNode.HasAttribute("id"))
scalar.Id = fieldNode.GetAttribute("id");
if (key != null)
scalar.Key = new QName(key, ns);
scalar.Dictionary = context.Dictionary;
ParseExternalAttributes(fieldNode, scalar);
return scalar;
}
private static Field createComposedDecimal(System.Xml.XmlElement fieldNode, QName name, bool optional, System.Xml.XmlNode mantissaNode, System.Xml.XmlNode exponentNode, ParsingContext context)
{
string mantissaOperator = "none";
string exponentOperator = "none";
ScalarValue mantissaDefaultValue = ScalarValue.UNDEFINED;
ScalarValue exponentDefaultValue = ScalarValue.UNDEFINED;
QName mantissaKey = null;
QName exponentKey = null;
string mantissaDictionary = context.Dictionary;
string exponentDictionary = context.Dictionary;
string mantissaNamespace = context.Namespace;
string exponentNamespace = context.Namespace;
if ((mantissaNode != null) && mantissaNode.HasChildNodes)
{
System.Xml.XmlElement operatorElement = GetElement((System.Xml.XmlElement) mantissaNode, 1);
mantissaOperator = operatorElement.Name;
if (operatorElement.HasAttribute("value"))
mantissaDefaultValue = FASTType.I64.GetValue(operatorElement.GetAttribute("value"));
if (operatorElement.HasAttribute("ns"))
mantissaNamespace = operatorElement.GetAttribute("ns");
if (operatorElement.HasAttribute("key"))
mantissaKey = new QName(operatorElement.GetAttribute("key"), mantissaNamespace);
if (operatorElement.HasAttribute("dictionary"))
mantissaDictionary = operatorElement.GetAttribute("dictionary");
}
if ((exponentNode != null) && exponentNode.HasChildNodes)
{
System.Xml.XmlElement operatorElement = GetElement((System.Xml.XmlElement) exponentNode, 1);
exponentOperator = operatorElement.Name;
if (operatorElement.HasAttribute("value"))
exponentDefaultValue = FASTType.I32.GetValue(operatorElement.GetAttribute("value"));
if (operatorElement.HasAttribute("ns"))
exponentNamespace = operatorElement.GetAttribute("ns");
if (operatorElement.HasAttribute("key"))
exponentKey = new QName(operatorElement.GetAttribute("key"), exponentNamespace);
if (operatorElement.HasAttribute("dictionary"))
exponentDictionary = operatorElement.GetAttribute("dictionary");
}
ComposedScalar scalar = Util.ComposedDecimal(name, Operator.Operator.GetOperator(exponentOperator), exponentDefaultValue, Operator.Operator.GetOperator(mantissaOperator), mantissaDefaultValue, optional);
Scalar exponent = scalar.Fields[0];
exponent.Dictionary = exponentDictionary;
if (exponentKey != null)
exponent.Key = exponentKey;
Scalar mantissa = scalar.Fields[1];
mantissa.Dictionary = mantissaDictionary;
if (mantissaKey != null)
mantissa.Key = mantissaKey;
if (fieldNode.HasAttribute("id"))
scalar.Id = fieldNode.GetAttribute("id");
return scalar;
}
protected internal static void ParseMore(XmlElement groupElement, Group group, ParsingContext context)
{
group.ChildNamespace = context.Namespace;
if (groupElement.HasAttribute("id"))
group.Id = groupElement.GetAttribute("id");
group.TypeReference = GetTypeReference(groupElement);
ParseExternalAttributes(groupElement, group);
}
public override Field Parse(XmlElement sequenceElement, bool optional, ParsingContext context)
{
var sequence = new Sequence(context.Name,
ParseSequenceLengthField(context.Name, sequenceElement, optional, context),
GroupParser.ParseFields(sequenceElement, context), optional);
GroupParser.ParseMore(sequenceElement, sequence.Group, context);
return sequence;
}
public override Field Parse(XmlElement fieldNode, bool optional, ParsingContext context)
{
var scalar = (Scalar) base.Parse(fieldNode, optional, context);
XmlElement element = GetElement(fieldNode, 1);
if (element != null && element.LocalName.Equals("length"))
{
string length = element.GetAttribute("name");
scalar.AddAttribute(FastConstants.LengthField, length);
}
return scalar;
}
public override bool CanParse(System.Xml.XmlElement element, ParsingContext context)
{
System.Xml.XmlNodeList children = element.ChildNodes;
for (int i = 0; i < children.Count; i++)
{
string nodeName = children.Item(i).Name;
if (nodeName.Equals("mantissa") || nodeName.Equals("exponent"))
return true;
}
return false;
}
public ParsingContext(System.Xml.XmlElement node, ParsingContext parent)
{
this.parent = parent;
if (node.HasAttribute("templateNs"))
TemplateNamespace = node.GetAttribute("templateNs");
if (node.HasAttribute("ns"))
Namespace = node.GetAttribute("ns");
if (node.HasAttribute("dictionary"))
Dictionary = node.GetAttribute("dictionary");
if (node.HasAttribute("name"))
setName(new QName(node.GetAttribute("name"), Namespace));
}
public ParsingContext(XmlElement node, ParsingContext parent)
{
_parent = parent;
if (node.HasAttribute("templateNs"))
TemplateNamespace = node.GetAttribute("templateNs");
if (node.HasAttribute("ns"))
Namespace = node.GetAttribute("ns");
if (node.HasAttribute("dictionary"))
Dictionary = node.GetAttribute("dictionary");
if (node.HasAttribute("name"))
_name = new QName(node.GetAttribute("name"), Namespace);
}
public void TestInheritDictionary()
{
var c = new ParsingContext(_context) {Dictionary = "template"};
XmlElement node = Document("<sequence name='seq'/>");
Assert.True(_parser.CanParse(node, c));
var sequence = (Sequence) _parser.Parse(node, c);
Assert.AreEqual("template", sequence.Length.Dictionary);
node = Document("<sequence name='seq'><length name='explicitLength'/></sequence>");
sequence = (Sequence) _parser.Parse(node, c);
Assert.AreEqual("template", sequence.Length.Dictionary);
}
public void TestInheritance()
{
const string ns = "http://openfast.org/test";
const string dictionary = "template";
var c = new ParsingContext(_context) {Dictionary = dictionary, Namespace = ns};
XmlElement node = Document("<sequence name='seq'><length name='seqLen'/></sequence>");
Assert.True(_parser.CanParse(node, c));
var sequence = (Sequence) _parser.Parse(node, c);
Assert.AreEqual(dictionary, sequence.Length.Dictionary);
Assert.AreEqual(ns, sequence.Length.QName.Namespace);
Assert.AreEqual(ns, sequence.QName.Namespace);
}
private Scalar ParseSequenceLengthField(QName name, System.Xml.XmlElement sequence, bool optional, ParsingContext parent)
{
System.Xml.XmlNodeList lengthElements = sequence.GetElementsByTagName("length");
if (lengthElements.Count == 0)
{
var implicitLength = new Scalar(Global.CreateImplicitName(name), FASTType.U32, Operator.Operator.NONE, ScalarValue.UNDEFINED, optional)
{Dictionary = parent.Dictionary};
return implicitLength;
}
var length = (System.Xml.XmlElement) lengthElements.Item(0);
var context = new ParsingContext(length, parent);
return (Scalar) sequenceLengthParser.Parse(length, optional, context);
}
public virtual Field Parse(XmlElement element, ParsingContext context)
{
if (element.HasAttribute("name"))
{
QName templateName = element.HasAttribute("templateNs")
? new QName(element.GetAttribute("name"), element.GetAttribute("templateNs"))
: new QName(element.GetAttribute("name"), "");
MessageTemplate template;
if (context.TemplateRegistry.TryGetTemplate(templateName, out template))
return new StaticTemplateReference(template);
context.ErrorHandler.OnError(null, DynError.TemplateNotExist, "The template '{0}' was not found.",
templateName);
return null;
}
return DynamicTemplateReference.Instance;
}
public override Field Parse(System.Xml.XmlElement fieldNode, bool optional, ParsingContext context)
{
System.Xml.XmlNodeList fieldChildren = fieldNode.ChildNodes;
System.Xml.XmlNode mantissaNode = null;
System.Xml.XmlNode exponentNode = null;
for (int i = 0; i < fieldChildren.Count; i++)
{
if ("mantissa".Equals(fieldChildren.Item(i).Name))
{
mantissaNode = fieldChildren.Item(i);
}
else if ("exponent".Equals(fieldChildren.Item(i).Name))
{
exponentNode = fieldChildren.Item(i);
}
}
return createComposedDecimal(fieldNode, context.GetName(), optional, mantissaNode, exponentNode, context);
}
public override Field Parse(XmlElement templateElement, bool optional, ParsingContext context)
{
var messageTemplate = new MessageTemplate(GetTemplateName(templateElement, context),
ParseFields(templateElement, context));
ParseMore(templateElement, messageTemplate, context);
if (_loadTemplateIdFromAuxId && templateElement.HasAttribute("id"))
{
try
{
int templateId = Int32.Parse(templateElement.GetAttribute("id"));
context.TemplateRegistry.Add(templateId, messageTemplate);
}
catch (FormatException)
{
context.TemplateRegistry.Define(messageTemplate);
}
}
else
context.TemplateRegistry.Define(messageTemplate);
return messageTemplate;
}
protected internal static Field[] ParseFields(System.Xml.XmlElement template, ParsingContext context)
{
System.Xml.XmlNodeList childNodes = template.ChildNodes;
var fields = new List<Field>();
for (int i = 0; i < childNodes.Count; i++)
{
System.Xml.XmlNode item = childNodes.Item(i);
if (IsElement(item))
{
if ("typeRef".Equals(item.Name) || "length".Equals(item.Name))
continue;
var element = (System.Xml.XmlElement) item;
FieldParser fieldParser = context.GetFieldParser(element);
if (fieldParser == null)
context.ErrorHandler.Error(Error.FastConstants.PARSE_ERROR, "No parser registered for " + element.Name);
if (fieldParser != null) fields.Add(fieldParser.Parse(element, context));
}
}
return fields.ToArray();
}
protected internal static Field[] ParseFields(XmlElement template, ParsingContext context)
{
XmlNodeList childNodes = template.ChildNodes;
var fields = new List<Field>();
for (int i = 0; i < childNodes.Count; i++)
{
XmlNode item = childNodes.Item(i);
if (IsElement(item))
{
if ("typeRef".Equals(item.LocalName) || "length".Equals(item.LocalName))
continue;
var element = (XmlElement) item;
IFieldParser fieldParser = context.GetFieldParser(element);
if (fieldParser == null)
context.ErrorHandler.OnError(null, DynError.ParseError, "No parser registered for {0}",
element.LocalName);
if (fieldParser != null) fields.Add(fieldParser.Parse(element, context));
}
}
return fields.ToArray();
}
public XmlMessageTemplateLoader()
{
_initialContext = CreateInitialContext();
}
protected void SetUp()
{
_parser = new ScalarParser();
_context = XmlMessageTemplateLoader.CreateInitialContext();
}
public MessageTemplate[] Load(XmlElement root)
{
var templateParser = new TemplateParser(_loadTemplateIdFromAuxId);
if (root != null)
{
if (root.LocalName.Equals("template"))
{
return new[] {(MessageTemplate) templateParser.Parse(root, _initialContext)};
}
if (root.LocalName.Equals("templates"))
{
var context = new ParsingContext(root, _initialContext);
XmlNodeList templateTags = root.GetElementsByTagName("template");
var templates = new MessageTemplate[templateTags.Count];
for (int i = 0; i < templateTags.Count; i++)
{
var templateTag = (XmlElement) templateTags.Item(i);
templates[i] = (MessageTemplate) templateParser.Parse(templateTag, context);
}
return templates;
}
_initialContext.ErrorHandler.OnError(
null, StaticError.InvalidXml, "Invalid root node {0}, 'template' or 'templates' expected.",
root.LocalName);
}
return new MessageTemplate[] {};
}
public override Field Parse(System.Xml.XmlElement groupElement, bool optional, ParsingContext context)
{
var group = new Group(context.GetName(), ParseFields(groupElement, context), optional);
ParseMore(groupElement, group, context);
return(group);
}
protected internal virtual QName GetName(System.Xml.XmlElement fieldNode, ParsingContext context)
{
return context.GetName();
}
protected internal virtual FASTType GetType(System.Xml.XmlElement fieldNode, ParsingContext context)
{
string typeName = GetTypeName(fieldNode);
if (!context.TypeMap.Contains(typeName))
{
context.ErrorHandler.Error(XMLMessageTemplateLoader.INVALID_TYPE, "The type " + typeName + " is not defined. Possible types: " + Util.CollectionToString(new SupportClass.HashSetSupport(context.TypeMap.Keys), ", "));
}
return (FASTType) context.TypeMap[typeName];
}
public override bool CanParse(System.Xml.XmlElement element, ParsingContext context)
{
return context.TypeMap.Contains(GetTypeName(element));
}
protected override QName GetName(XmlElement fieldNode, ParsingContext context)
{
if (context.Name == null)
return Global.CreateImplicitName(context.Parent.Name);
return context.Name;
}
public override bool CanParse(XmlElement element, ParsingContext context)
{
return element.LocalName.Equals("string");
}
public static ParsingContext CreateInitialContext()
{
var initialContext = new ParsingContext
{
ErrorHandler = ErrorHandlerFields.Default,
TemplateRegistry = new BasicTemplateRegistry(),
TypeMap = FastType.RegisteredTypeMap,
FieldParsers = new List<IFieldParser>()
};
initialContext.AddFieldParser(new ScalarParser());
initialContext.AddFieldParser(new GroupParser());
initialContext.AddFieldParser(new SequenceParser());
initialContext.AddFieldParser(new ComposedDecimalParser());
initialContext.AddFieldParser(new StringParser());
initialContext.AddFieldParser(new ByteVectorParser());
initialContext.AddFieldParser(new TemplateRefParser());
return initialContext;
}
protected override FastType GetType(XmlElement fieldNode, ParsingContext context)
{
return FastType.U32;
}
public override Field Parse(XmlElement groupElement, bool optional, ParsingContext context)
{
var group = new Group(context.Name, ParseFields(groupElement, context), optional);
ParseMore(groupElement, group, context);
return group;
}
protected void SetUp()
{
_parser = new ComposedDecimalParser();
_context = XmlMessageTemplateLoader.CreateInitialContext();
}
public override bool CanParse(XmlElement element, ParsingContext context)
{
return("byteVector".Equals(element.LocalName));
}
public XmlMessageTemplateLoader()
{
_initialContext = CreateInitialContext();
}
public ParsingContext(ParsingContext parent)
{
_parent = parent;
}
public virtual bool CanParse(XmlElement element, ParsingContext context)
{
return("templateRef".Equals(element.LocalName));
}
protected internal static Field[] ParseFields(System.Xml.XmlElement template, ParsingContext context)
{
System.Xml.XmlNodeList childNodes = template.ChildNodes;
var fields = new List <Field>();
for (int i = 0; i < childNodes.Count; i++)
{
System.Xml.XmlNode item = childNodes.Item(i);
if (IsElement(item))
{
if ("typeRef".Equals(item.Name) || "length".Equals(item.Name))
{
continue;
}
var element = (System.Xml.XmlElement)item;
FieldParser fieldParser = context.GetFieldParser(element);
if (fieldParser == null)
{
context.ErrorHandler.Error(Error.FastConstants.PARSE_ERROR, "No parser registered for " + element.Name);
}
if (fieldParser != null)
{
fields.Add(fieldParser.Parse(element, context));
}
}
}
return(fields.ToArray());
}
public virtual bool CanParse(XmlElement element, ParsingContext context)
{
return "templateRef".Equals(element.LocalName);
}
protected internal static void ParseMore(System.Xml.XmlElement groupElement, Group group, ParsingContext context)
{
group.ChildNamespace = context.Namespace;
if (groupElement.HasAttribute("id"))
{
group.Id = groupElement.GetAttribute("id");
}
group.TypeReference = GetTypeReference(groupElement);
ParseExternalAttributes(groupElement, group);
}
