protected XExtension Parse(XmlReader reader) { XExtension extension = null; XAttribute currentAttribute = null; Dictionary <string, XAttribute> xAttributes = null; IXFactory factory = XFactoryRegistry.Instance.CurrentDefault; while (reader.Read()) { // When a start tag is found if (reader.IsStartElement()) { string tagName = reader.LocalName; if (tagName.Equals("", StringComparison.CurrentCultureIgnoreCase)) { tagName = reader.Name; } if (tagName.Equals("xesextension", StringComparison.CurrentCultureIgnoreCase)) { string xName = reader.GetAttribute("name"); string xPrefix = reader.GetAttribute("prefix"); Uri xUri = null; try { xUri = new Uri(reader.GetAttribute("uri")); } catch (UriFormatException e) { XLogging.Log(e.Message, XLogging.Importance.ERROR); throw e; } extension = new XExtension(xName, xPrefix, xUri); } else if (tagName.Equals("log", StringComparison.CurrentCultureIgnoreCase)) { xAttributes = extension.LogAttributes; } else if (tagName.Equals("trace", StringComparison.CurrentCultureIgnoreCase)) { xAttributes = extension.TraceAttributes; } else if (tagName.Equals("event", StringComparison.CurrentCultureIgnoreCase)) { xAttributes = extension.EventAttributes; } else if (tagName.Equals("meta", StringComparison.CurrentCultureIgnoreCase)) { xAttributes = extension.MetaAttributes; } else if (tagName.Equals("string", StringComparison.CurrentCultureIgnoreCase)) { string key = reader.GetAttribute("key"); currentAttribute = factory.CreateAttributeLiteral(key, "DEFAULT", extension); xAttributes.Add(key, currentAttribute); } else if (tagName.Equals("date", StringComparison.CurrentCultureIgnoreCase)) { string key = reader.GetAttribute("key"); currentAttribute = factory.CreateAttributeTimestamp(key, 0L, extension); xAttributes.Add(key, currentAttribute); } else if (tagName.Equals("int", StringComparison.CurrentCultureIgnoreCase)) { string key = reader.GetAttribute("key"); currentAttribute = factory.CreateAttributeDiscrete(key, 0L, extension); xAttributes.Add(key, currentAttribute); } else if (tagName.Equals("float", StringComparison.CurrentCultureIgnoreCase)) { string key = reader.GetAttribute("key"); currentAttribute = factory.CreateAttributeContinuous(key, 0.0D, extension); xAttributes.Add(key, currentAttribute); } else if (tagName.Equals("boolean", StringComparison.CurrentCultureIgnoreCase)) { string key = reader.GetAttribute("key"); currentAttribute = factory.CreateAttributeBoolean(key, false, extension); xAttributes.Add(key, currentAttribute); } else if (tagName.Equals("id", StringComparison.CurrentCultureIgnoreCase)) { string key = reader.GetAttribute("key"); currentAttribute = factory.CreateAttributeID(key, XIDFactory.Instance.CreateId(), extension); xAttributes.Add(key, currentAttribute); } else if (tagName.Equals("alias", StringComparison.CurrentCultureIgnoreCase) && currentAttribute != null) { string mapping = reader.GetAttribute("mapping"); string name = reader.GetAttribute("name"); XGlobalAttributeNameMap.Instance.RegisterMapping(mapping, currentAttribute.Key, name); } else { // non supported tag XLogging.Log(String.Format("Non-supported tag '{0}' found. Ignoring it.", tagName), XLogging.Importance.TRACE); } } // When a close tag is found (including empty elements) if (reader.IsEmptyElement || !reader.IsStartElement()) { string tagName = reader.LocalName; if (tagName.Equals("", StringComparison.InvariantCultureIgnoreCase)) { tagName = reader.Name; } if (ATTRIBUTE_TYPES.Contains(tagName.Trim().ToLower())) { currentAttribute = null; } } } return(extension); }
XSoftwareEventExtension() : base("Software evt", "swevent", EXTENSION_URI) { IXFactory factory = XFactoryRegistry.Instance.CurrentDefault; #region Application Information ATTR_APP_NAME = factory.CreateAttributeLiteral(KEY_APP_NAME, "__INVALID__", this); this.eventAttributes.Add(KEY_APP_NAME, (XAttribute)ATTR_APP_NAME.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_APP_NAME), "User defined application name"); ATTR_APP_NODE = factory.CreateAttributeLiteral(KEY_APP_NODE, "__INVALID__", this); this.eventAttributes.Add(KEY_APP_NODE, (XAttribute)ATTR_APP_NODE.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_APP_NODE), "User defined application node"); ATTR_APP_SESSION = factory.CreateAttributeLiteral(KEY_APP_SESSION, "__INVALID__", this); this.eventAttributes.Add(KEY_APP_SESSION, (XAttribute)ATTR_APP_SESSION.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_APP_SESSION), "User defined application session"); ATTR_APP_TIER = factory.CreateAttributeLiteral(KEY_APP_TIER, "__INVALID__", this); this.eventAttributes.Add(KEY_APP_TIER, (XAttribute)ATTR_APP_TIER.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_APP_TIER), "User defined application tier"); #endregion #region Callee event location ATTR_CALLEE_PACKAGE = factory.CreateAttributeLiteral(KEY_CALLEE_PACKAGE, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLEE_PACKAGE, (XAttribute)ATTR_CALLEE_PACKAGE.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_PACKAGE), "Callee - Package"); ATTR_CALLEE_CLASS = factory.CreateAttributeLiteral(KEY_CALLEE_CLASS, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLEE_CLASS, (XAttribute)ATTR_CALLEE_CLASS.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_CLASS), "Callee - Class"); ATTR_CALLEE_METHOD = factory.CreateAttributeLiteral(KEY_CALLEE_METHOD, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLEE_METHOD, (XAttribute)ATTR_CALLEE_METHOD.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_METHOD), "Callee - Method"); ATTR_CALLEE_PARAMSIG = factory.CreateAttributeLiteral(KEY_CALLEE_PARAMSIG, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLEE_PARAMSIG, (XAttribute)ATTR_CALLEE_PARAMSIG.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_PARAMSIG), "Callee - Parameter signature"); ATTR_CALLEE_RETURNSIG = factory.CreateAttributeLiteral(KEY_CALLEE_RETURNSIG, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLEE_RETURNSIG, (XAttribute)ATTR_CALLEE_RETURNSIG.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_RETURNSIG), "Callee - Return signature"); ATTR_CALLEE_ISCONSTRUCTOR = factory.CreateAttributeBoolean(KEY_CALLEE_ISCONSTRUCTOR, false, this); this.eventAttributes.Add(KEY_CALLEE_ISCONSTRUCTOR, (XAttribute)ATTR_CALLEE_ISCONSTRUCTOR.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_ISCONSTRUCTOR), "Callee - Is a class constructor"); ATTR_CALLEE_INSTANCEID = factory.CreateAttributeLiteral(KEY_CALLEE_INSTANCEID, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLEE_INSTANCEID, (XAttribute)ATTR_CALLEE_INSTANCEID.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_INSTANCEID), "Callee - Instance id of class instance"); ATTR_CALLEE_FILENAME = factory.CreateAttributeLiteral(KEY_CALLEE_FILENAME, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLEE_FILENAME, (XAttribute)ATTR_CALLEE_FILENAME.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_FILENAME), "Callee - File name source code artifact"); ATTR_CALLEE_LINENR = factory.CreateAttributeDiscrete(KEY_CALLEE_LINENR, -1L, this); this.eventAttributes.Add(KEY_CALLEE_LINENR, (XAttribute)ATTR_CALLEE_LINENR.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLEE_LINENR), "Callee - Line number is source code artifact"); #endregion #region Caller event Location ATTR_CALLER_PACKAGE = factory.CreateAttributeLiteral(KEY_CALLER_PACKAGE, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLER_PACKAGE, (XAttribute)ATTR_CALLER_PACKAGE.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_PACKAGE), "Caller - Package"); ATTR_CALLER_CLASS = factory.CreateAttributeLiteral(KEY_CALLER_CLASS, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLER_CLASS, (XAttribute)ATTR_CALLER_CLASS.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_CLASS), "Caller - Class"); ATTR_CALLER_METHOD = factory.CreateAttributeLiteral(KEY_CALLER_METHOD, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLER_METHOD, (XAttribute)ATTR_CALLER_METHOD.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_METHOD), "Caller - Method"); ATTR_CALLER_PARAMSIG = factory.CreateAttributeLiteral(KEY_CALLER_PARAMSIG, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLER_PARAMSIG, (XAttribute)ATTR_CALLER_PARAMSIG.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_PARAMSIG), "Caller - Parameter signature"); ATTR_CALLER_RETURNSIG = factory.CreateAttributeLiteral(KEY_CALLER_RETURNSIG, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLER_RETURNSIG, (XAttribute)ATTR_CALLER_RETURNSIG.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_RETURNSIG), "Caller - Return signature"); ATTR_CALLER_ISCONSTRUCTOR = factory.CreateAttributeBoolean(KEY_CALLER_ISCONSTRUCTOR, false, this); this.eventAttributes.Add(KEY_CALLER_ISCONSTRUCTOR, (XAttribute)ATTR_CALLER_ISCONSTRUCTOR.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_ISCONSTRUCTOR), "Caller - Is a class constructor"); ATTR_CALLER_INSTANCEID = factory.CreateAttributeLiteral(KEY_CALLER_INSTANCEID, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLER_INSTANCEID, (XAttribute)ATTR_CALLER_INSTANCEID.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_INSTANCEID), "Caller - Instance id of class instance"); ATTR_CALLER_FILENAME = factory.CreateAttributeLiteral(KEY_CALLER_FILENAME, "__INVALID__", this); this.eventAttributes.Add(KEY_CALLER_FILENAME, (XAttribute)ATTR_CALLER_FILENAME.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_FILENAME), "Caller - File name source code artifact"); ATTR_CALLER_LINENR = factory.CreateAttributeDiscrete(KEY_CALLER_LINENR, -1L, this); this.eventAttributes.Add(KEY_CALLER_LINENR, (XAttribute)ATTR_CALLER_LINENR.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_CALLER_LINENR), "Caller - Line number is source code artifact"); #endregion #region Exception Information ATTR_HAS_EXCEPTION = factory.CreateAttributeBoolean(KEY_HAS_EXCEPTION, false, this); this.logAttributes.Add(KEY_HAS_EXCEPTION, (XAttribute)ATTR_HAS_EXCEPTION.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_HAS_EXCEPTION), "Has exception data"); ATTR_EX_CAUGHT = factory.CreateAttributeLiteral(KEY_EX_CAUGHT, "__INVALID__", this); this.eventAttributes.Add(KEY_EX_CAUGHT, (XAttribute)ATTR_EX_CAUGHT.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_EX_CAUGHT), "Caught exception type"); ATTR_EX_THROWN = factory.CreateAttributeLiteral(KEY_EX_THROWN, "__INVALID__", this); this.eventAttributes.Add(KEY_EX_THROWN, (XAttribute)ATTR_EX_THROWN.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_EX_THROWN), "Thrown exception type"); #endregion #region Runtime Information ATTR_NANOTIME = factory.CreateAttributeDiscrete(KEY_NANOTIME, -1L, this); this.eventAttributes.Add(KEY_NANOTIME, (XAttribute)ATTR_NANOTIME.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_NANOTIME), "Elapsed nanotime"); ATTR_THREAD_ID = factory.CreateAttributeLiteral(KEY_THREAD_ID, "__INVALID__", this); this.eventAttributes.Add(KEY_THREAD_ID, (XAttribute)ATTR_THREAD_ID.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_THREAD_ID), "Thread id for generated event"); #endregion #region Method Data ATTR_HAS_DATA = factory.CreateAttributeBoolean(KEY_HAS_DATA, false, this); this.logAttributes.Add(KEY_HAS_DATA, (XAttribute)ATTR_HAS_DATA.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_HAS_DATA), "Has method data"); ATTR_RETURN_VALUE = factory.CreateAttributeLiteral(KEY_RETURN_VALUE, "__INVALID__", this); this.eventAttributes.Add(KEY_RETURN_VALUE, (XAttribute)ATTR_RETURN_VALUE.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_RETURN_VALUE), "Return value for the returning method"); ATTR_PARAMS = factory.CreateAttributeList(KEY_PARAMS, this); this.eventAttributes.Add(KEY_PARAMS, (XAttribute)ATTR_PARAMS.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_PARAMS), "List of parameters for the called method"); ATTR_PARAM_VALUE = factory.CreateAttributeLiteral(KEY_PARAM_VALUE, "__INVALID__", this); this.metaAttributes.Add(KEY_PARAM_VALUE, (XAttribute)ATTR_PARAM_VALUE.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_PARAM_VALUE), "A parameter value in the list params"); ATTR_VALUE_TYPE = factory.CreateAttributeLiteral(KEY_VALUE_TYPE, "__INVALID__", this); this.metaAttributes.Add(KEY_VALUE_TYPE, (XAttribute)ATTR_VALUE_TYPE.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_VALUE_TYPE), "A runtime value type for a return or parameter value"); #endregion #region Event type and lifecycle ATTR_TYPE = factory.CreateAttributeLiteral(KEY_TYPE, "__INVALID__", this); this.eventAttributes.Add(KEY_TYPE, (XAttribute)ATTR_TYPE.Clone()); XGlobalAttributeNameMap.Instance.RegisterMapping("EN", QualifiedName(KEY_TYPE), "Event type"); #endregion }
public override IXLog Parse(Stream stream) { Stack <IXAttributable> attributableStack = new Stack <IXAttributable>(); Stack <XAttribute> attributeStack = new Stack <XAttribute>(); IXEvent evt = null; IXLog log = null; IXTrace trace = null; List <XAttribute> globals = null; using (XmlReader reader = XmlReader.Create(stream)) { List <string> ATTR_TYPE_TAGS = new List <string>(new string[] { "string", "date", "int", "float", "boolean", "id", "list", "container" }); ATTR_TYPE_TAGS.Sort(); while (reader.Read()) { if (reader.IsStartElement()) { // start tag found string tagName = reader.LocalName.Trim(); if (tagName.Length == 0) { tagName = reader.Name.Trim(); // <= qualified name } if (ATTR_TYPE_TAGS.Contains(tagName.ToLower())) { // The tag is an attribute string key = reader.GetAttribute("key") ?? ""; string val = reader.GetAttribute("value") ?? ""; XExtension ext = null; int colonindex = key.IndexOf(":", StringComparison.InvariantCultureIgnoreCase); if (colonindex > 0) { string prefix = key.Substring(0, colonindex); ext = XExtensionManager.Instance.GetByPrefix(prefix); } XAttribute attr = null; switch (tagName) { case "string": attr = factory.CreateAttributeLiteral(key, val, ext); break; case "int": attr = factory.CreateAttributeDiscrete(key, long.Parse(val), ext); break; case "boolean": attr = factory.CreateAttributeBoolean(key, bool.Parse(val), ext); break; case "date": DateTime d = XAttributeTimestamp.Parse(val); attr = factory.CreateAttributeTimestamp(key, d, ext); break; case "float": attr = factory.CreateAttributeContinuous(key, double.Parse(val), ext); break; case "id": attr = factory.CreateAttributeID(key, XID.Parse(val), ext); break; case "list": attr = factory.CreateAttributeList(key, ext); break; case "container": attr = factory.CreateAttributeContainer(key, ext); break; default: XLogging.Log("Unknown tag '" + tagName + "'", XLogging.Importance.WARNING); break; } if (reader.IsEmptyElement) { // No child nodes, we can directly store it if (globals != null) { // attribute is global globals.Add(attr); } else { attributableStack.Peek().GetAttributes().Add(attr.Key, attr); if ((!(attributeStack.Count == 0)) && (attributeStack.Peek() is XAttributeCollection)) { ((XAttributeCollection)attributeStack.Peek()).AddToCollection(attr); } } } else if (attr != null) { attributeStack.Push(attr); attributableStack.Push((IXAttributable)attr); } } else if ("event".Equals(tagName.ToLower())) { // Parse an event evt = factory.CreateEvent(); attributableStack.Push(evt); } else if ("trace".Equals(tagName.ToLower())) { trace = factory.CreateTrace(); attributableStack.Push(trace); } else if ("log".Equals(tagName.ToLower())) { log = factory.CreateLog(); ((XLog)log).Version = reader.GetAttribute("xes.version") ?? "2.0"; ((XLog)log).Features = reader.GetAttribute("xes.features") ?? ""; attributableStack.Push(log); } else if ("extension".Equals(tagName.ToLower())) { XExtension extension = null; String uriString = reader.GetAttribute("uri"); if (uriString != null) { extension = XExtensionManager.Instance.GetByUri(new UriBuilder(uriString).Uri); } else { string prefixString = reader.GetAttribute("prefix"); if (prefixString != null) { extension = XExtensionManager.Instance.GetByPrefix(prefixString); } } if (extension != null) { log.Extensions.Add(extension); } else { XLogging.Log("Unknown extension: " + uriString, XLogging.Importance.ERROR); } } else if ("global".Equals(tagName.ToLower())) { string scope = reader.GetAttribute("scope"); if (scope.Equals("trace")) { globals = log.GlobalTraceAttributes; } else if (scope.Equals("event")) { globals = log.GlobalEventAttributes; } } else if ("classifier".Equals(tagName.ToLower())) { string name = reader.GetAttribute("name"); string keys = reader.GetAttribute("keys"); if ((name == null) || (keys == null) || (name.Length <= 0) || (keys.Length <= 0)) { continue; } IList <string> keysList = FixKeys(log, XTokenHelper.ExtractTokens(keys)); string[] keysArray = new string[keysList.Count]; int i = 0; foreach (string key in keysList) { keysArray[(i++)] = key; } IXEventClassifier classifier = new XEventAttributeClassifier(name, keysArray); log.Classifiers.Add(classifier); } } else { // end tag found string tagName = reader.LocalName.Trim().ToLower(); if (tagName.Length == 0) { tagName = reader.Name.Trim().ToLower(); // <= qualified name } if ("global".Equals(tagName)) { globals = null; } else if (ATTR_TYPE_TAGS.Contains(tagName)) { XAttribute attribute = attributeStack.Pop(); attributableStack.Pop(); if (globals != null) { globals.Add(attribute); } else { attributableStack.Peek().GetAttributes().Add(attribute.Key, attribute); if ((!(attributeStack.Count == 0)) && (attributeStack.Peek() is XAttributeCollection)) { ((XAttributeCollection)attributeStack.Peek()).AddToCollection(attribute); } } } else if ("event".Equals(tagName)) { trace.Add(evt); evt = null; attributableStack.Pop(); } else if ("trace".Equals(tagName)) { log.Add(trace); trace = null; attributableStack.Pop(); } else if ("log".Equals(tagName)) { attributableStack.Pop(); } } } } return(log); }
/// <summary> /// Composes the appropriate attribute type from the string-based information /// found, e.g., in XML serializations. /// </summary> /// <returns>An appropriate attribute.</returns> /// <param name="factory">Factory to use for creating the attribute.</param> /// <param name="key">Key of the attribute.</param> /// <param name="value">Value of the attribute.</param> /// <param name="type">Type string of the attribute.</param> /// <param name="extension">Extension of the attribute (can be <code>null</code>).</param> public static XAttribute ComposeAttribute(IXFactory factory, string key, string value, string type, XExtension extension) { type = type.Trim(); if (type.Equals("LIST", StringComparison.CurrentCultureIgnoreCase)) { XAttributeList attr = factory.CreateAttributeList(key, extension); return(attr); } if (type.Equals("CONTAINER", StringComparison.CurrentCultureIgnoreCase)) { XAttributeContainer attr = factory.CreateAttributeContainer(key, extension); return(attr); } if (type.Equals("LITERAL", StringComparison.CurrentCultureIgnoreCase)) { XAttributeLiteral attr = factory.CreateAttributeLiteral(key, value, extension); return(attr); } if (type.Equals("BOOLEAN", StringComparison.CurrentCultureIgnoreCase)) { XAttributeBoolean attr = factory.CreateAttributeBoolean(key, bool.Parse(value), extension); return(attr); } if (type.Equals("CONTINUOUS", StringComparison.CurrentCultureIgnoreCase)) { XAttributeContinuous attr = factory.CreateAttributeContinuous(key, double.Parse(value), extension); return(attr); } if (type.Equals("DISCRETE", StringComparison.CurrentCultureIgnoreCase)) { XAttributeDiscrete attr = factory.CreateAttributeDiscrete(key, long.Parse(value), extension); return(attr); } if (type.Equals("TIMESTAMP", StringComparison.CurrentCultureIgnoreCase)) { IXAttributeTimestamp attr; try { attr = factory.CreateAttributeTimestamp(key, DateTime.Parse(value), extension); } catch (FormatException) { throw new InvalidOperationException("OpenXES: could not parse date-time attribute. Value: " + value); } return((XAttributeTimestamp)attr); } if (type.Equals("ID", StringComparison.CurrentCultureIgnoreCase)) { XAttributeID attr = factory.CreateAttributeID(key, XID.Parse(value), extension); return(attr); } throw new InvalidOperationException("OpenXES: could not parse attribute type!"); }