| public abstract MoveToFirstAttribute ( ) : bool | ||
| return | bool | |
public static XmlNode[] ReadNodes(XmlReader xmlReader)
{
if (xmlReader == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlReader");
XmlDocument doc = new XmlDocument();
List<XmlNode> nodeList = new List<XmlNode>();
if (xmlReader.MoveToFirstAttribute())
{
do
{
if (IsValidAttribute(xmlReader))
{
XmlNode node = doc.ReadNode(xmlReader);
if (node == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.UnexpectedEndOfFile)));
nodeList.Add(node);
}
} while (xmlReader.MoveToNextAttribute());
}
xmlReader.MoveToElement();
if (!xmlReader.IsEmptyElement)
{
int startDepth = xmlReader.Depth;
xmlReader.Read();
while (xmlReader.Depth > startDepth && xmlReader.NodeType != XmlNodeType.EndElement)
{
XmlNode node = doc.ReadNode(xmlReader);
if (node == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.UnexpectedEndOfFile)));
nodeList.Add(node);
}
}
return nodeList.ToArray();
}
public string GetValue(string key)
{
_reader = XmlReader.Create(_configFile);
_reader.ReadToFollowing(key);
_reader.MoveToFirstAttribute();
return _reader.Value;
}
public static bool CheckPerspexRoot(XmlReader reader)
{
try
{
while (!reader.IsStartElement())
{
reader.Read();
}
if (!reader.MoveToFirstAttribute())
return false;
do
{
if (reader.Name == "xmlns")
{
reader.ReadAttributeValue();
return reader.Value.ToLower() == PerspexNamespace;
}
} while (reader.MoveToNextAttribute());
return false;
}
catch
{
return false;
}
}
object Read(XmlReader reader, Type type)
{
var obj = Activator.CreateInstance(type);
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
do
{
var propertyInfo = type.GetProperty(reader.Name);
propertyInfo
.SetValue(
obj,
Convert.ChangeType(reader.Value, propertyInfo.PropertyType)
);
} while (reader.MoveToNextAttribute());
}
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
var propertyInfo = type.GetProperty(reader.Name);
propertyInfo
.SetValue(
obj,
ReadValue(reader, propertyInfo.PropertyType)
);
break;
}
}
return obj;
}
internal static ClassData Read(XmlReader xmlReader)
{
var classData = new ClassData();
xmlReader.MoveToFirstAttribute();
do
{
if (xmlReader.Name.Length > 0)
{
switch (xmlReader.Name)
{
case ("typeName"):
{
classData.TypeName = xmlReader.Value;
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}
}
} while (xmlReader.MoveToNextAttribute());
while (xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.EndElement)
{
break;
}
if (xmlReader.IsStartElement())
{
switch (xmlReader.Name)
{
case("method"):
{
var methodData = MethodData.Read(xmlReader);
classData.Methods.Add(methodData);
break;
}
case("property"):
{
var propertyData = PropertyData.Read(xmlReader);
classData.Properties.Add(propertyData);
break;
}
case("field"):
{
var fieldData = FieldData.Read(xmlReader);
classData.Fields.Add(fieldData);
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}}
}
xmlReader.Read();
return classData;
}
private void LoadScenario(XmlReader reader, Scenario scenario)
{
while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "Stack")
{
var stack = new Stack();
scenario.Stacks[reader.GetAttribute("name")] = stack;
var stackAttributes = new Dictionary<string, string>();
if (reader.MoveToFirstAttribute())
{
for (; ; )
{
if (reader.Name != "name")
stackAttributes.Add(reader.Name, reader.Value);
if (!reader.MoveToNextAttribute())
break;
}
reader.MoveToElement();
}
reader.ReadStartElement("Stack");
LoadStack(reader, stack);
reader.ReadEndElement();
foreach (var attr in stackAttributes)
_stackDecorator[attr.Key](stack, attr.Value);
}
else
{
reader.Read();
}
}
}
private static IEnumerable<string> ReadMedia(XmlReader media)
{
while (media.ReadToFollowing("local"))
{
media.MoveToFirstAttribute();
yield return media.ReadContentAsString();
}
}
internal static MethodData Read(XmlReader xmlReader)
{
var methodData = new MethodData();
xmlReader.MoveToFirstAttribute();
do
{
if (xmlReader.Name.Length > 0)
{
switch (xmlReader.Name)
{
case ("name"):
{
methodData.Name = xmlReader.Value;
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}
}
} while (xmlReader.MoveToNextAttribute());
while (xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.EndElement)
{
break;
}
if (xmlReader.IsStartElement())
{
switch (xmlReader.Name)
{
case ("overloadType"):
{
var typeData = TypeData.Read(xmlReader);
methodData.OverloadTypes.Add(typeData);
break;
}
case ("parameter"):
{
var parameterData = ParameterData.Read(xmlReader);
methodData.Parameters.Add(parameterData);
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}
}
}
xmlReader.Read();
return methodData;
}
public static IfNotStatement Read (XmlReader reader)
{
IfNotStatement result = new IfNotStatement ();
if (reader.MoveToFirstAttribute ()) {
do {
result.SetAttribute (reader.LocalName, reader.Value);
} while (reader.MoveToNextAttribute ());
}
result.Children = Node.ReadNodeList (reader, XmlTag);
return result;
}
public Strand(XmlReader r)
{
// The reader is currently positioned at the start of a strand element.
// r.Name is currently "s"
r.MoveToFirstAttribute();
_level = uint.Parse(r.Value);
_values = K.GetUIntList(r.ReadString());
// r.Name is the end tag "s" here
K.ReadToXmlElementTag(r, "s", "strands");
// r.Name is either the start tag "s" of a new strand
// or the end tag "strands"
}
internal static FieldData Read(XmlReader xmlReader)
{
var fieldData = new FieldData();
xmlReader.MoveToFirstAttribute();
do
{
if (xmlReader.Name.Length > 0)
{
switch (xmlReader.Name)
{
case ("name"):
{
fieldData.Name = xmlReader.Value;
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}
}
} while (xmlReader.MoveToNextAttribute());
while (xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.EndElement)
{
break;
}
if (xmlReader.IsStartElement())
{
switch (xmlReader.Name)
{
case ("rule"):
{
var ruleData = RuleData.Read(xmlReader);
fieldData.RuleDatas.Add(ruleData);
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}
}
}
xmlReader.Read();
return fieldData;
}
public bool MoveNext()
{
if (!_complete)
{
switch (_reader.NodeType)
{
case XmlNodeType.Attribute:
var result = _reader.MoveToNextAttribute();
_complete = !result;
return(result);
default:
return(_reader.MoveToFirstAttribute());
}
}
return(false);
}
public void Update(XmlReader rd)
{
Trace.Assert(m_name == rd.Name);
Trace.Assert(rd.NodeType == XmlNodeType.Element);
m_count++;
if (rd.MoveToFirstAttribute())
{
do
{
var attrName = rd.Name;
if (!m_attributeCounts.ContainsKey(attrName))
m_attributeCounts.Add(attrName, 0);
m_attributeCounts[attrName] = m_attributeCounts[attrName] + 1;
} while (rd.MoveToNextAttribute());
}
}
private string ConvertToJsonAttributes(XmlReader xmlReader)
{
string result = "";
if (xmlReader.HasAttributes)
{
result = string.Format("{0}\"atributes\" : [\r\n", new string('\t', tabCount));
xmlReader.MoveToFirstAttribute();
++tabCount;
for (int i = 0; i < xmlReader.AttributeCount; i++)
{
result += new string('\t', tabCount) +
string.Format("\"{0}\" : \"{1}\",\r\n", xmlReader.Name, xmlReader.Value);
xmlReader.MoveToNextAttribute();
}
--tabCount;
result += string.Format("{0}],\r\n", new string('\t', tabCount));
xmlReader.MoveToElement();
}
return result;
}
private static IEnumerable<NodeAttribute> GetAttributes(XmlReader reader)
{
var tokens = new List<Pair<string, string>>();
if (reader.MoveToFirstAttribute())
{
do
{
tokens.Add(new Pair<string, string>(reader.Name, reader.Value));
} while (reader.MoveToNextAttribute());
}
reader.MoveToElement();
for (int i = 0; i < tokens.Count; i++)
{
yield return new NodeAttribute(i, tokens[i].First, tokens[i].Second, tokens.Count);
}
}
public static System.Xml.XmlNode[] ReadNodes(XmlReader xmlReader)
{
if (xmlReader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlReader");
}
XmlDocument document = new XmlDocument();
List<System.Xml.XmlNode> list = new List<System.Xml.XmlNode>();
if (xmlReader.MoveToFirstAttribute())
{
do
{
if (IsValidAttribute(xmlReader))
{
System.Xml.XmlNode item = document.ReadNode(xmlReader);
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("UnexpectedEndOfFile")));
}
list.Add(item);
}
}
while (xmlReader.MoveToNextAttribute());
}
xmlReader.MoveToElement();
if (!xmlReader.IsEmptyElement)
{
int depth = xmlReader.Depth;
xmlReader.Read();
while ((xmlReader.Depth > depth) && (xmlReader.NodeType != XmlNodeType.EndElement))
{
System.Xml.XmlNode node2 = document.ReadNode(xmlReader);
if (node2 == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("UnexpectedEndOfFile")));
}
list.Add(node2);
}
}
return list.ToArray();
}
public static SwitchStatement Read (XmlReader reader)
{
var result = new SwitchStatement ();
if (reader.MoveToFirstAttribute ()) {
do {
result.SetAttribute (reader.LocalName, reader.Value);
} while (reader.MoveToNextAttribute ());
}
XmlReadHelper.ReadList (reader, XmlTag, delegate () {
switch (reader.LocalName) {
case "Case":
result.CaseSections.Add (CaseStatement.Read (reader));
return true;
case "Default":
result.Children = Node.ReadNodeList (reader, "Default");
return true;
}
return false;
});
return result;
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.MoveToFirstAttribute())
{
TransactionId = new Guid(reader.GetAttribute("transactionId"));
_name = reader.GetAttribute("name");
IsolationLevel = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), reader.GetAttribute("isolationLevel"));
CreatedOn = DateTime.Parse(reader.GetAttribute("createdOn"));
TransactionState = (TransactionState)Enum.Parse(typeof(TransactionState), reader.GetAttribute("transactionState"));
// Setting the IsStarted property is important so that our checks to see if the
// Transaction is started are valid.
IDisposable tx = TransactionManager.Instance.GetTransaction(this);
if (tx == null)
{
IsStarted = false;
}
else
{
IsStarted = true;
}
}
}
private bool IsCollection()
{
var isCollection = false;
if (reader.HasAttributes)
{
var ok = reader.MoveToFirstAttribute();
while (ok)
{
var name = reader.Name;
var attName = name.ChangeCase(TextCase.PascalCase);
if (attName.Equals("IsArray"))
{
isCollection = (reader.Value == "true") || (reader.Value == "1");
break;
}
ok = reader.MoveToNextAttribute();
}
}
reader.MoveToElement();
return(isCollection);
}
internal static TypeData Read(XmlReader xmlReader)
{
var typeData = new TypeData();
xmlReader.MoveToFirstAttribute();
do
{
if (xmlReader.Name.Length > 0)
{
switch (xmlReader.Name)
{
case ("typeName"):
{
typeData.TypeName = xmlReader.Value;
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}
}
} while (xmlReader.MoveToNextAttribute());
return typeData;
}
// returns remaining attributes to be processed
Dictionary<string,string> ProcessAttributes (XmlReader r, List<Pair> members)
{
var l = members;
// base (top element)
if (!xmlbase_done) {
xmlbase_done = true;
string xmlbase = r.GetAttribute ("base", XamlLanguage.Xml1998Namespace) ?? r.BaseURI;
if (xmlbase != null)
l.Add (new Pair (XamlLanguage.Base, xmlbase));
}
var atts = new Dictionary<string,string> ();
if (r.MoveToFirstAttribute ()) {
do {
switch (r.NamespaceURI) {
case XamlLanguage.Xml1998Namespace:
switch (r.LocalName) {
case "base":
continue; // already processed.
case "lang":
l.Add (new Pair (XamlLanguage.Lang, r.Value));
continue;
case "space":
l.Add (new Pair (XamlLanguage.Space, r.Value));
continue;
}
break;
case XamlLanguage.Xmlns2000Namespace:
continue;
case XamlLanguage.Xaml2006Namespace:
XamlDirective d = FindStandardDirective (r.LocalName, AllowedMemberLocations.Attribute);
if (d != null) {
l.Add (new Pair (d, r.Value));
continue;
}
throw new NotSupportedException (String.Format ("Attribute '{0}' is not supported", r.Name));
default:
if (r.NamespaceURI == String.Empty) {
atts.Add (r.Name, r.Value);
continue;
}
// Should we just ignore unknown attribute in XAML namespace or any other namespaces ?
// Probably yes for compatibility with future version.
break;
}
} while (r.MoveToNextAttribute ());
r.MoveToElement ();
}
return atts;
}
// Reads XmlReader and creates Attribute Node.
private XmlAttribute ReadAttributeNode (XmlReader reader)
{
if (reader.NodeType == XmlNodeType.Element)
reader.MoveToFirstAttribute ();
else if (reader.NodeType != XmlNodeType.Attribute)
throw new InvalidOperationException (MakeReaderErrorMessage ("bad position to read attribute.", reader));
XmlAttribute attribute = CreateAttribute (reader.Prefix, reader.LocalName, reader.NamespaceURI);
#if NET_2_0
if (reader.SchemaInfo != null)
SchemaInfo = reader.SchemaInfo;
#endif
bool isDefault = reader.IsDefault;
ReadAttributeNodeValue (reader, attribute);
if (isDefault)
attribute.SetDefault ();
return attribute;
}
private void PopulateNode(WsXmlNode node, WsXmlNode parent, XmlReader reader)
{
node.LocalName = reader.LocalName;
node.NamespaceURI = reader.NamespaceURI;
node.Prefix = reader.Prefix;
node.ParentNode = parent;
// Read attributes if they exist
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
do
{
WsXmlAttribute attribute = new WsXmlAttribute();
attribute.Value = reader.Value;
attribute.LocalName = reader.LocalName;
if (reader.NamespaceURI != String.Empty)
{
attribute.NamespaceURI = reader.NamespaceURI;
}
attribute.Prefix = reader.Prefix;
node.Attributes.Append(attribute);
}
while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
}
internal static XElement LoadCore (XmlReader r, LoadOptions options)
{
r.MoveToContent ();
if (r.NodeType != XmlNodeType.Element)
throw new InvalidOperationException ("The XmlReader must be positioned at an element");
XName name = XName.Get (r.LocalName, r.NamespaceURI);
XElement e = new XElement (name);
e.FillLineInfoAndBaseUri (r, options);
if (r.MoveToFirstAttribute ()) {
do {
// not sure how current Orcas behavior makes sense here though ...
if (r.LocalName == "xmlns" && r.NamespaceURI == XNamespace.Xmlns.NamespaceName)
e.SetAttributeValue (XNamespace.None.GetName ("xmlns"), r.Value);
else
e.SetAttributeValue (XName.Get (r.LocalName, r.NamespaceURI), r.Value);
e.LastAttribute.FillLineInfoAndBaseUri (r, options);
} while (r.MoveToNextAttribute ());
r.MoveToElement ();
}
if (!r.IsEmptyElement) {
r.Read ();
e.ReadContentFrom (r, options);
r.ReadEndElement ();
e.explicit_is_empty = false;
} else {
e.explicit_is_empty = true;
r.Read ();
}
return e;
}
/* -------------------------------------------------------------------------------------
* Name: WriteShallowNode
* Goal: Copy piece-by-piece
* History:
* 2/oct/2015 ERK Created
------------------------------------------------------------------------------------- */
public void WriteShallowNode(XmlReader reader, XmlWriter writer)
{
if (reader == null) {
throw new ArgumentNullException("reader");
}
if (writer == null) {
throw new ArgumentNullException("writer");
}
try {
switch (reader.NodeType) {
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
bool bIsFOLIA = (reader.LocalName == "FoLiA");
string sLocalName = reader.LocalName;
// Process attributes one by one
if (reader.HasAttributes) {
if (reader.MoveToFirstAttribute()) {
do {
if (reader.Name != "xmlns") {
bool bWritten = false;
// Action depends on local name
switch (sLocalName) {
case "FoLiA":
// Is the the attribute @version?
if (reader.Name == "version") { writer.WriteAttributeString(reader.Name, FOLIA_VERSION); bWritten = true; }
break;
case "t":
// is this the attribute @class?
if (reader.Name == "class") { writer.WriteAttributeString(reader.Name, "eng"); bWritten = true; }
break;
}
if (!bWritten) {
String[] arName = reader.Name.Split(':');
if (arName.Length > 1) {
writer.WriteAttributeString(arName[0], arName[1], null, reader.Value);
} else {
writer.WriteAttributeString(reader.Name, reader.Value);
}
}
/*
// Check for FoLiA version
if (bIsFOLIA && reader.Name == "version") {
// Adapt version number
writer.WriteAttributeString(reader.Name, FOLIA_VERSION);
} else {
String[] arName = reader.Name.Split(':');
if (arName.Length > 1) {
writer.WriteAttributeString(arName[0], arName[1], null, reader.Value);
} else {
writer.WriteAttributeString(reader.Name, reader.Value);
}
} */
}
} while (reader.MoveToNextAttribute());
}
}
if (reader.IsEmptyElement) {
writer.WriteEndElement();
}
break;
case XmlNodeType.Text:
writer.WriteString(reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
writer.WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
}
} catch (Exception ex) {
errHandle.DoError("WriteShallowNode", ex); // Provide standard error message
}
}
/// <summary>
/// Converts XML to JsonML array form.
/// </summary>
public static void EncodeArrayForm(XmlReader reader, JsonWriter writer)
{
if (reader == null) throw new ArgumentNullException("reader");
if (writer == null) throw new ArgumentNullException("writer");
if (reader.MoveToContent() != XmlNodeType.Element)
throw new ArgumentException(null, "reader");
writer.WriteStartArray();
writer.WriteString(reader.Name);
//
// Write attributes
//
if (reader.MoveToFirstAttribute())
{
writer.WriteStartObject();
do
{
writer.WriteMember(reader.Name);
writer.WriteString(reader.Value);
}
while (reader.MoveToNextAttribute());
writer.WriteEndObject();
reader.MoveToElement();
}
bool isEmpty = reader.IsEmptyElement;
if (!isEmpty)
{
reader.Read();
//
// Write child nodes (text, CDATA and element)
//
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA)
{
writer.WriteString(reader.Value);
reader.Read();
}
else if (reader.NodeType == XmlNodeType.Element)
{
Encode(reader, writer);
}
else
{
reader.Read();
}
}
}
writer.WriteEndArray();
reader.Read();
}
// XmlReader Helper Methods
// Writes out all the attributes found at the current position in the specified XmlReader.
public virtual void WriteAttributes(XmlReader reader, bool defattr)
{
if (null == reader)
{
throw new ArgumentNullException(nameof(reader));
}
if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.XmlDeclaration)
{
if (reader.MoveToFirstAttribute())
{
WriteAttributes(reader, defattr);
reader.MoveToElement();
}
}
else if (reader.NodeType != XmlNodeType.Attribute)
{
throw new XmlException(SR.Xml_InvalidPosition, string.Empty);
}
else
{
do
{
// we need to check both XmlReader.IsDefault and XmlReader.SchemaInfo.IsDefault.
// If either of these is true and defattr=false, we should not write the attribute out
if (defattr || !reader.IsDefaultInternal)
{
WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
while (reader.ReadAttributeValue())
{
if (reader.NodeType == XmlNodeType.EntityReference)
{
WriteEntityRef(reader.Name);
}
else
{
WriteString(reader.Value);
}
}
WriteEndAttribute();
}
}
while (reader.MoveToNextAttribute());
}
}
private void ParseStep(XmlReader reader, Stack<ElementRecord> elementStack, ref TextRecord textChunk, PhpArray values, PhpArray indices)
{
string elementName;
bool emptyElement;
ElementRecord currentElementRecord = null;
switch (reader.NodeType)
{
case XmlNodeType.Element:
elementName = reader.Name;
emptyElement = reader.IsEmptyElement;
PhpArray attributeArray = new PhpArray();
if (_processNamespaces && elementName.IndexOf(":") >= 0)
{
string localName = elementName.Substring(elementName.IndexOf(":") + 1);
elementName = reader.NamespaceURI + _namespaceSeparator + localName;
}
if (reader.MoveToFirstAttribute())
{
do
{
if (_processNamespaces && reader.Name.StartsWith("xmlns:"))
{
string namespaceID = reader.Name.Substring(6);
string namespaceUri = reader.Value;
if (_startNamespaceDeclHandler.Callback != null)
_startNamespaceDeclHandler.Invoke(this, namespaceID, namespaceUri);
continue;
}
attributeArray.Add(_enableCaseFolding ? reader.Name.ToUpperInvariant() : reader.Name, reader.Value);
}
while (reader.MoveToNextAttribute());
}
// update current top of stack
if (elementStack.Count != 0)
{
currentElementRecord = elementStack.Peek();
UpdateValueAndIndexArrays(currentElementRecord, ref textChunk, values, indices, true);
if (currentElementRecord.State == ElementState.Beginning)
currentElementRecord.State = ElementState.Interior;
}
// push the element into the stack (needed for parse_into_struct)
elementStack.Push(
new ElementRecord() {
ElementName = elementName,
Level = reader.Depth,
State = ElementState.Beginning,
Attributes = (PhpArray)attributeArray.DeepCopy()
});
if (_startElementHandler.Callback != null)
_startElementHandler.Invoke(this, _enableCaseFolding ? elementName.ToUpperInvariant() : elementName, attributeArray);
else
if (_defaultHandler.Callback != null) _defaultHandler.Invoke(this, "");
if (emptyElement) goto case XmlNodeType.EndElement; // and end the element immediately (<element/>, XmlNodeType.EndElement will not be called)
break;
case XmlNodeType.EndElement:
elementName = reader.Name;
if (_processNamespaces && elementName.IndexOf(":") >= 0)
{
string localName = elementName.Substring(elementName.IndexOf(":") + 1);
elementName = reader.NamespaceURI + _namespaceSeparator + localName;
}
// pop the top element record
currentElementRecord = elementStack.Pop();
UpdateValueAndIndexArrays(currentElementRecord, ref textChunk, values, indices, false);
if (_endElementHandler.Callback != null)
_endElementHandler.Invoke(this, _enableCaseFolding ? elementName.ToUpperInvariant() : elementName);
else
if (_defaultHandler.Callback != null) _defaultHandler.Invoke(this, "");
break;
case XmlNodeType.Whitespace:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
if (textChunk == null)
{
textChunk = new TextRecord() { Text = reader.Value };
}
else
{
textChunk.Text += reader.Value;
}
if (_characterDataHandler.Callback != null)
_characterDataHandler.Invoke(this, reader.Value);
else
if (_defaultHandler.Callback != null) _defaultHandler.Invoke(this, reader.Value);
break;
case XmlNodeType.ProcessingInstruction:
if (_processingInstructionHandler.Callback != null)
_processingInstructionHandler.Invoke(this, reader.Name, reader.Value);
else
if (_defaultHandler.Callback != null) _defaultHandler.Invoke(this, string.Empty);
break;
}
}
private XmlNode LoadNode(bool skipOverWhitespace)
{
XmlElement element;
IXmlSchemaInfo schemaInfo;
XmlNode node2;
XmlReader reader = this.reader;
XmlNode parentNode = null;
Label_0009:
node2 = null;
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
bool isEmptyElement = reader.IsEmptyElement;
element = this.doc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
element.IsEmpty = isEmptyElement;
if (reader.MoveToFirstAttribute())
{
XmlAttributeCollection attributes = element.Attributes;
do
{
XmlAttribute attribute = this.LoadAttributeNode();
attributes.Append(attribute);
}while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
if (isEmptyElement)
{
schemaInfo = reader.SchemaInfo;
if (schemaInfo != null)
{
element.XmlName = this.doc.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
}
node2 = element;
break;
}
if (parentNode != null)
{
parentNode.AppendChildForLoad(element, this.doc);
}
parentNode = element;
goto Label_025B;
}
case XmlNodeType.Attribute:
node2 = this.LoadAttributeNode();
break;
case XmlNodeType.Text:
node2 = this.doc.CreateTextNode(reader.Value);
break;
case XmlNodeType.CDATA:
node2 = this.doc.CreateCDataSection(reader.Value);
break;
case XmlNodeType.EntityReference:
node2 = this.LoadEntityReferenceNode(false);
break;
case XmlNodeType.ProcessingInstruction:
node2 = this.doc.CreateProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Comment:
node2 = this.doc.CreateComment(reader.Value);
break;
case XmlNodeType.DocumentType:
node2 = this.LoadDocumentTypeNode();
break;
case XmlNodeType.Whitespace:
if (!this.preserveWhitespace)
{
if ((parentNode == null) && !skipOverWhitespace)
{
return(null);
}
goto Label_025B;
}
node2 = this.doc.CreateWhitespace(reader.Value);
break;
case XmlNodeType.SignificantWhitespace:
node2 = this.doc.CreateSignificantWhitespace(reader.Value);
break;
case XmlNodeType.EndElement:
if (parentNode != null)
{
schemaInfo = reader.SchemaInfo;
if (schemaInfo != null)
{
element = parentNode as XmlElement;
if (element != null)
{
element.XmlName = this.doc.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
}
}
if (parentNode.ParentNode == null)
{
return(parentNode);
}
parentNode = parentNode.ParentNode;
goto Label_025B;
}
return(null);
case XmlNodeType.EndEntity:
return(null);
case XmlNodeType.XmlDeclaration:
node2 = this.LoadDeclarationNode();
break;
default:
throw UnexpectedNodeType(reader.NodeType);
}
if (parentNode != null)
{
parentNode.AppendChildForLoad(node2, this.doc);
}
else
{
return(node2);
}
Label_025B:
if (reader.Read())
{
goto Label_0009;
}
if (parentNode != null)
{
while (parentNode.ParentNode != null)
{
parentNode = parentNode.ParentNode;
}
}
return(parentNode);
}
public override bool MoveToFirstAttribute()
{
return(reader.MoveToFirstAttribute());
}
public override bool MoveToFirstAttribute()
{
CheckAsync();
return(_coreReader.MoveToFirstAttribute());
}
public static List <XmlReadInstructions> AnalyseXmlReader(System.Xml.XmlReader reader, bool globalUniqueColumnNames)
{
var root = new Node();
var current = root;
var resultSets = new Dictionary <string, Node>();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
current = current.SubElement(reader.Name);
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
do
{
current.Attribute(reader.Name);
} while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
if (current.CurrentCount > 1)
{
string xpath = current.AbsXPath;
if (!resultSets.ContainsKey(xpath))
{
resultSets[xpath] = current;
current.IsRepetetive = true;
}
}
if (reader.IsEmptyElement)
{
current = current.Parent;
}
break;
case XmlNodeType.Text:
if (!String.IsNullOrWhiteSpace(reader.Value))
{
current.HasText = true;
}
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Comment:
continue;
case XmlNodeType.EndElement:
current = current.Parent;
break;
}
}
// remove repetetive parents. Remains only innermost repetetives
foreach (var resultSet in resultSets.Values.ToList())
{
var node = resultSet;
node = node.Parent;
while (node != null && !node.IsRepetetive)
{
node = node.Parent;
}
if (node != null)
{
resultSets.Remove(node.AbsXPath);
node.IsRepetetive = false;
}
}
if (!resultSets.Any())
{
resultSets["/"] = root;
}
var res = new List <XmlReadInstructions>();
var addedColumns = new HashSet <string>();
var collectionNames = new HashSet <string>();
foreach (var resultSet in resultSets.Values)
{
var instruction = new XmlReadInstructions();
instruction.XPath = resultSet.AbsXPath ?? "/";
string collectionName = resultSet.Name;
if (collectionNames.Contains(collectionName))
{
int index = 2;
while (collectionNames.Contains(collectionName + index))
{
index++;
}
collectionName = collectionName + index;
}
instruction.CollectionName = collectionName;
if (!globalUniqueColumnNames)
{
addedColumns.Clear();
}
CollectColumns(instruction, root, addedColumns, resultSet);
if (resultSet != root)
{
CollectColumns(instruction, resultSet, addedColumns, resultSet);
}
res.Add(instruction);
}
return(res);
}
/// <summary>
/// Writes the element attributes from the reader to the writer
/// </summary>
protected virtual void WriteAttributes(XmlReader reader, XmlWriter writer) {
Contract.Requires(reader != null);
Contract.Requires(writer != null);
if (reader.MoveToFirstAttribute()) {
do { writer.WriteAttributeString(reader.Name, reader.Value); }
while (reader.MoveToNextAttribute());
}
}
private void TestAttributeDefaultContributionInternal (XmlReader dvr)
{
dvr.Read (); // DTD
dvr.Read ();
Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
Assert.AreEqual ("root", dvr.Name);
Assert.AreEqual (2, dvr.AttributeCount);
// foo
Assert.IsTrue (dvr.MoveToFirstAttribute ());
Assert.AreEqual ("foo", dvr.Name);
Assert.AreEqual ("foo-def", dvr ["foo"]);
Assert.IsNotNull (dvr ["bar"]);
Assert.AreEqual ("foo-def", dvr.Value);
Assert.IsTrue (dvr.ReadAttributeValue ());
Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
Assert.AreEqual (String.Empty, dvr.Name);
Assert.AreEqual ("foo-def", dvr.Value);
// bar
Assert.IsTrue (dvr.MoveToNextAttribute ());
Assert.AreEqual ("bar", dvr.Name);
Assert.AreEqual ("foo-def", dvr ["foo"]);
Assert.IsNotNull (dvr ["bar"]);
Assert.AreEqual ("bar-def", dvr.Value);
Assert.IsTrue (dvr.ReadAttributeValue ());
Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
Assert.AreEqual (String.Empty, dvr.Name);
Assert.AreEqual ("bar-def", dvr.Value);
}
// LoadNodeDirect does not use creator functions on XmlDocument. It is used loading nodes that are children of entity nodes,
// because we do not want to let users extend these (if we would allow this, XmlDataDocument would have a problem, because
// they do not know that those nodes should not be mapped). It can be also used for an optimized load path when if the
// XmlDocument is not extended if XmlDocumentType and XmlDeclaration handling is added.
private XmlNode LoadNodeDirect()
{
XmlReader r = _reader;
XmlNode parent = null;
do
{
XmlNode node = null;
switch (r.NodeType)
{
case XmlNodeType.Element:
bool fEmptyElement = _reader.IsEmptyElement;
XmlElement element = new XmlElement(_reader.Prefix, _reader.LocalName, _reader.NamespaceURI, _doc);
element.IsEmpty = fEmptyElement;
if (_reader.MoveToFirstAttribute())
{
XmlAttributeCollection attributes = element.Attributes;
do
{
XmlAttribute attr = LoadAttributeNodeDirect();
attributes.Append(attr); // special case for load
} while (r.MoveToNextAttribute());
}
// recursively load all children.
if (!fEmptyElement)
{
parent.AppendChildForLoad(element, _doc);
parent = element;
continue;
}
else
{
node = element;
break;
}
case XmlNodeType.EndElement:
Debug.Assert(parent.NodeType == XmlNodeType.Element);
if (parent.ParentNode == null)
{
return(parent);
}
parent = parent.ParentNode;
continue;
case XmlNodeType.EntityReference:
node = LoadEntityReferenceNode(true);
break;
case XmlNodeType.EndEntity:
continue;
case XmlNodeType.Attribute:
node = LoadAttributeNodeDirect();
break;
case XmlNodeType.SignificantWhitespace:
node = new XmlSignificantWhitespace(_reader.Value, _doc);
break;
case XmlNodeType.Whitespace:
if (_preserveWhitespace)
{
node = new XmlWhitespace(_reader.Value, _doc);
}
else
{
continue;
}
break;
case XmlNodeType.Text:
node = new XmlText(_reader.Value, _doc);
break;
case XmlNodeType.CDATA:
node = new XmlCDataSection(_reader.Value, _doc);
break;
case XmlNodeType.ProcessingInstruction:
node = new XmlProcessingInstruction(_reader.Name, _reader.Value, _doc);
break;
case XmlNodeType.Comment:
node = new XmlComment(_reader.Value, _doc);
break;
default:
throw UnexpectedNodeType(_reader.NodeType);
}
Debug.Assert(node != null);
if (parent != null)
{
parent.AppendChildForLoad(node, _doc);
}
else
{
return(node);
}
}while (r.Read());
return(null);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Reads a Supported Features from an XmlReader
/// </summary>
/// <param name="reader">The XmlReader to use</param>
/// <history>
/// [cnurse] 01/17/2008 Created
/// </history>
/// -----------------------------------------------------------------------------
private void ReadSupportedFeatures(XmlReader reader)
{
SupportedFeatures = 0;
reader.ReadStartElement("supportedFeatures");
do
{
if (reader.HasAttributes)
{
reader.MoveToFirstAttribute();
switch (reader.ReadContentAsString())
{
case "Portable":
IsPortable = true;
break;
case "Searchable":
IsSearchable = true;
break;
case "Upgradeable":
IsUpgradeable = true;
break;
}
}
} while (reader.ReadToNextSibling("supportedFeature"));
}
public override object Parse(System.Xml.XmlReader s, DatatypeFormatterParseResult result)
{
// Create the types
Type ivlType = typeof(IVL <>);
Type ivlGenericType = ivlType.MakeGenericType(GenericArguments);
// Sometimes there can be just a messy, unstructured value inline with this IVL (like in CCDA) so we still need to support that
MemoryStream leftOvers = new MemoryStream();
XmlWriter leftoverWriter = XmlWriter.Create(leftOvers);
leftoverWriter.WriteStartElement(s.LocalName, s.NamespaceURI);
// Create an instance of rto from the rtoType
object instance = ivlGenericType.GetConstructor(Type.EmptyTypes).Invoke(null);
if (s.MoveToFirstAttribute())
{
do
{
switch (s.LocalName)
{
case "nullFlavor":
((ANY)instance).NullFlavor = (NullFlavor)Util.FromWireFormat(s.GetAttribute("nullFlavor"), typeof(NullFlavor));
break;
case "operator":
ivlGenericType.GetProperty("Operator").SetValue(instance, Util.FromWireFormat(s.GetAttribute("operator"), typeof(SetOperator?)), null);
break;
case "specializationType":
if (result.CompatibilityMode == DatatypeFormatterCompatibilityMode.Canadian)
{
((ANY)instance).Flavor = s.GetAttribute("specializationType");
}
break;
default:
leftoverWriter.WriteAttributeString(s.Prefix, s.LocalName, s.NamespaceURI, s.Value);
break;
}
} while (s.MoveToNextAttribute());
s.MoveToElement();
}
// Get property information
PropertyInfo lowProperty = ivlGenericType.GetProperty("Low"),
highProperty = ivlGenericType.GetProperty("High"),
widthProperty = ivlGenericType.GetProperty("Width"),
centerProperty = ivlGenericType.GetProperty("Center"),
lowClosedProperty = ivlGenericType.GetProperty("LowClosed"),
highClosedProperty = ivlGenericType.GetProperty("HighClosed"),
valueProperty = ivlGenericType.GetProperty("Value");
// Now process the elements
#region Elements
if (!s.IsEmptyElement)
{
int sDepth = s.Depth;
string sName = s.Name;
s.Read();
// string Name
while (!(s.NodeType == System.Xml.XmlNodeType.EndElement && s.Depth == sDepth && s.Name == sName))
{
string oldName = s.Name; // Name
try
{
if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "low") // low value
{
if (!String.IsNullOrEmpty(s.GetAttribute("inclusive")))
{
lowClosedProperty.SetValue(instance, Util.FromWireFormat(s.GetAttribute("inclusive"), typeof(bool?)), null);
}
var parseResult = Host.Parse(s, GenericArguments[0]);
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
lowProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "high") // high value
{
if (!String.IsNullOrEmpty(s.GetAttribute("inclusive")))
{
highClosedProperty.SetValue(instance, Util.FromWireFormat(s.GetAttribute("inclusive"), typeof(bool?)), null);
}
var parseResult = Host.Parse(s, GenericArguments[0]);
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
highProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "center") // center
{
var parseResult = Host.Parse(s, GenericArguments[0]);
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
centerProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element && s.LocalName == "width") // width
{
var parseResult = Host.Parse(s, typeof(PQ));
result.Code = parseResult.Code;
result.AddResultDetail(parseResult.Details);
widthProperty.SetValue(instance, parseResult.Structure, null);
}
else if (s.NodeType == System.Xml.XmlNodeType.Element)
{
leftoverWriter.WriteNode(s, true);
//result.AddResultDetail(new NotImplementedElementResultDetail(ResultDetailType.Warning, s.LocalName, s.NamespaceURI, s.ToString(), null));
}
}
catch (MessageValidationException e) // Message validation error
{
result.AddResultDetail(new MARC.Everest.Connectors.ResultDetail(MARC.Everest.Connectors.ResultDetailType.Error, e.Message, e));
}
finally
{
if (s.Name == oldName)
{
s.Read();
}
}
}
}
#endregion
// Process any leftovers as Value !!!
try
{
leftoverWriter.WriteEndElement();
leftoverWriter.Flush();
leftOvers.Seek(0, SeekOrigin.Begin);
using (XmlReader xr = XmlReader.Create(leftOvers))
{
xr.MoveToContent();
if (xr.AttributeCount > 1 || !xr.IsEmptyElement)
{
bool isNotEmpty = !xr.IsEmptyElement;
if (xr.MoveToFirstAttribute())
{
do
{
isNotEmpty |= xr.Prefix != "xmlns" && xr.LocalName != "xmlns" && xr.NamespaceURI != DatatypeFormatter.NS_XSI;
} while (!isNotEmpty && xr.MoveToNextAttribute());
}
xr.MoveToElement();
if (isNotEmpty)
{
var baseResult = base.Parse(xr, result);
valueProperty.SetValue(instance, Util.FromWireFormat(baseResult, valueProperty.PropertyType), null);
}
}
}
}
catch { }
// Validate
base.Validate(instance as ANY, s.LocalName, result);
return(instance);
}
private static bool CompareAttributes(
XmlReader reader1,
XmlReader reader2)
{
bool more = true;
more = reader1.MoveToFirstAttribute();
if (more ^ reader2.MoveToFirstAttribute())
{
return false;
}
while (more)
{
if (reader1.Prefix == "xmlns")
{
if (reader2.Prefix != "xmlns" ||
reader1.IsEmptyElement != reader2.IsEmptyElement ||
reader1.Value != reader2.Value)
{
return false;
}
}
else
{
if (reader1.LocalName != reader2.LocalName ||
reader1.NamespaceURI != reader2.NamespaceURI ||
reader1.IsEmptyElement != reader2.IsEmptyElement ||
reader1.Value != reader2.Value)
{
return false;
}
}
more = reader1.MoveToNextAttribute();
if (more ^ reader2.MoveToNextAttribute())
{
return false;
}
}
return true;
}
private XmlNode LoadNode(bool skipOverWhitespace)
{
XmlReader r = _reader;
XmlNode parent = null;
XmlElement element;
IXmlSchemaInfo schemaInfo;
do
{
XmlNode node = null;
switch (r.NodeType)
{
case XmlNodeType.Element:
bool fEmptyElement = r.IsEmptyElement;
element = _doc.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI);
element.IsEmpty = fEmptyElement;
if (r.MoveToFirstAttribute())
{
XmlAttributeCollection attributes = element.Attributes;
do
{
XmlAttribute attr = LoadAttributeNode();
attributes.Append(attr); // special case for load
}while (r.MoveToNextAttribute());
r.MoveToElement();
}
// recursively load all children.
if (!fEmptyElement)
{
if (parent != null)
{
parent.AppendChildForLoad(element, _doc);
}
parent = element;
continue;
}
else
{
schemaInfo = r.SchemaInfo;
if (schemaInfo != null)
{
element.XmlName = _doc.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
}
node = element;
break;
}
case XmlNodeType.EndElement:
if (parent == null)
{
return(null);
}
Debug.Assert(parent.NodeType == XmlNodeType.Element);
schemaInfo = r.SchemaInfo;
if (schemaInfo != null)
{
element = parent as XmlElement;
if (element != null)
{
element.XmlName = _doc.AddXmlName(element.Prefix, element.LocalName, element.NamespaceURI, schemaInfo);
}
}
if (parent.ParentNode == null)
{
return(parent);
}
parent = parent.ParentNode;
continue;
case XmlNodeType.EntityReference:
node = LoadEntityReferenceNode(false);
break;
case XmlNodeType.EndEntity:
Debug.Assert(parent == null);
return(null);
case XmlNodeType.Attribute:
node = LoadAttributeNode();
break;
case XmlNodeType.Text:
node = _doc.CreateTextNode(r.Value);
break;
case XmlNodeType.SignificantWhitespace:
node = _doc.CreateSignificantWhitespace(r.Value);
break;
case XmlNodeType.Whitespace:
if (_preserveWhitespace)
{
node = _doc.CreateWhitespace(r.Value);
break;
}
else if (parent == null && !skipOverWhitespace)
{
// if called from LoadEntityReferenceNode, just return null
return(null);
}
else
{
continue;
}
case XmlNodeType.CDATA:
node = _doc.CreateCDataSection(r.Value);
break;
case XmlNodeType.XmlDeclaration:
node = LoadDeclarationNode();
break;
case XmlNodeType.ProcessingInstruction:
node = _doc.CreateProcessingInstruction(r.Name, r.Value);
break;
case XmlNodeType.Comment:
node = _doc.CreateComment(r.Value);
break;
case XmlNodeType.DocumentType:
node = LoadDocumentTypeNode();
break;
default:
throw UnexpectedNodeType(r.NodeType);
}
Debug.Assert(node != null);
if (parent != null)
{
parent.AppendChildForLoad(node, _doc);
}
else
{
return(node);
}
}while (r.Read());
// when the reader ended before full subtree is read, return whatever we have created so far
if (parent != null)
{
while (parent.ParentNode != null)
{
parent = parent.ParentNode;
}
}
return(parent);
}
/// <summary>
/// Converts XML to JsonML object form.
/// </summary>
public static void EncodeObjectForm(XmlReader reader, JsonWriter writer)
{
if (reader == null) throw new ArgumentNullException("reader");
if (writer == null) throw new ArgumentNullException("writer");
if (reader.MoveToContent() != XmlNodeType.Element)
throw new ArgumentException(null, "reader");
writer.WriteStartObject();
writer.WriteMember("tagName");
writer.WriteString(reader.Name);
//
// Write attributes
//
if (reader.MoveToFirstAttribute())
{
do
{
writer.WriteMember(reader.Name);
writer.WriteString(reader.Value);
}
while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
bool isEmpty = reader.IsEmptyElement;
if (!isEmpty)
{
reader.Read();
int childCount = 0;
//
// Write child nodes (text, CDATA and element)
//
XmlNodeType nodeType;
while ((nodeType = reader.NodeType) != XmlNodeType.EndElement)
{
if (nodeType == XmlNodeType.Text
|| nodeType == XmlNodeType.CDATA
|| nodeType == XmlNodeType.Element)
{
if (childCount == 0)
{
writer.WriteMember("childNodes");
writer.WriteStartArray();
}
if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.CDATA)
{
writer.WriteString(reader.Value);
reader.Read();
}
else if (nodeType == XmlNodeType.Element)
{
EncodeObjectForm(reader, writer);
}
childCount++;
}
else
{
reader.Read();
}
}
if (childCount > 0)
writer.WriteEndArray();
}
writer.WriteEndObject();
reader.Read();
}
public DataTable GetProjectTable(string subFolder)
{
DataTable table = new DataTable();
table.Columns.Add(new DataColumn("TemplateName", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("TemplateDescription", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("TemplatePath", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("TemplateCreateDate", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("Name", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("Location", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("Description", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("EpiVersion", System.Type.GetType("System.String")));
table.Columns.Add(new DataColumn("CreateDate", System.Type.GetType("System.String")));
DataRow row;
string projectFolderPath = Path.Combine(templatesPath, subFolder);
if (Directory.Exists(projectFolderPath) != true)
{
return(table);
}
String[] projectTemplates = GetFiles(projectFolderPath, "*.xml;*.eit");
foreach (string path in projectTemplates)
{
row = table.NewRow();
try
{
using (System.Xml.XmlReader reader = System.Xml.XmlReader.Create(path))
{
while (reader.ReadToFollowing("Template"))
{
if (reader.MoveToFirstAttribute())
{
AddAttributeToProjectTableRow(row, reader);
while (reader.MoveToNextAttribute())
{
AddAttributeToProjectTableRow(row, reader);
}
while (reader.ReadToFollowing("Project"))
{
if (reader.MoveToFirstAttribute())
{
if (table.Columns.Contains(reader.Name))
{
row[reader.Name] = reader.Value;
}
while (reader.MoveToNextAttribute())
{
if (table.Columns.Contains(reader.Name))
{
row[reader.Name] = reader.Value;
}
}
}
}
row["TemplatePath"] = path;
table.Rows.Add(row);
}
}
}
}
catch {}
}
return(table);
}
