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!");
}