| public abstract MoveToFirstAttribute ( ) : bool | ||
| return | bool | |
public ParameterNode(XPathNavigator aNode)
{
valueNode = String.Empty;
typeNode = String.Empty;
ruleValueNode = String.Empty;
name = String.Empty;
if (aNode.MoveToFirstAttribute())
{
do
{
string nodeName = aNode.Name;
switch (nodeName)
{
case PARAMETER_ATTRS.NAME:
name = aNode.Value;
break;
case PARAMETER_ATTRS.VALUE:
valueNode = aNode.Value;
break;
case PARAMETER_ATTRS.TYPE:
typeNode = aNode.Value;
break;
case PARAMETER_ATTRS.RULE_VALUE:
ruleValueNode = aNode.Value;
break;
}
} while (aNode.MoveToNextAttribute());
aNode.MoveToParent();
}
}
public MSXslScript (XPathNavigator nav, Evidence evidence)
{
this.evidence = evidence;
code = nav.Value;
if (nav.MoveToFirstAttribute ()) {
do {
switch (nav.LocalName) {
case "language":
switch (nav.Value.ToLower (CultureInfo.InvariantCulture)) {
case "jscript":
case "javascript":
language = ScriptingLanguage.JScript; break;
case "vb":
case "visualbasic":
language = ScriptingLanguage.VisualBasic;
break;
case "c#":
case "csharp":
language = ScriptingLanguage.CSharp;
break;
default:
throw new XsltException ("Invalid scripting language!", null);
}
break;
case "implements-prefix":
implementsPrefix = nav.Value;
break;
}
} while (nav.MoveToNextAttribute ());
nav.MoveToParent ();
}
if (implementsPrefix == null)
throw new XsltException ("need implements-prefix attr", null);
}
public void ReadXml(XPathNavigator node)
{
if (node.MoveToFirstAttribute()) {
do {
if (String.IsNullOrEmpty(node.NamespaceURI)) {
switch (node.LocalName) {
case "address":
this.Address = node.Value;
break;
case "display-name":
this.DisplayName = node.Value;
break;
default:
break;
}
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
}
/// <summary>
/// Initializes a new instance of an XmlNodeTaskItem
/// </summary>
/// <param name="xpathNavigator">The selected XmlNode</param>
/// <param name="reservedMetaDataPrefix">The prefix to attach to the reserved metadata properties.</param>
public XmlNodeTaskItem(XPathNavigator xpathNavigator, string reservedMetaDataPrefix)
{
this.ReservedMetaDataPrefix = reservedMetaDataPrefix;
switch (xpathNavigator.NodeType)
{
case XPathNodeType.Attribute:
itemSpec = xpathNavigator.Value;
break;
default:
itemSpec = xpathNavigator.Name;
break;
}
metaData.Add(ReservedMetaDataPrefix + "value", xpathNavigator.Value);
metaData.Add(ReservedMetaDataPrefix + "innerXml", xpathNavigator.InnerXml);
metaData.Add(ReservedMetaDataPrefix + "outerXml", xpathNavigator.OuterXml);
if (xpathNavigator.MoveToFirstAttribute())
{
do
{
metaData.Add(xpathNavigator.Name, xpathNavigator.Value);
} while (xpathNavigator.MoveToNextAttribute());
}
}
private void Parse(XPathNavigator classCacheElement)
{
if (classCacheElement.MoveToFirstAttribute())
{
do
{
switch (classCacheElement.Name)
{
case "class":
if (classCacheElement.Value.Trim().Length == 0)
throw new HibernateConfigException("Invalid class-cache element; the attribute <class> must be assigned with no empty value");
clazz = classCacheElement.Value;
break;
case "usage":
usage = EntityCacheUsageParser.Parse(classCacheElement.Value);
break;
case "region":
region = classCacheElement.Value;
break;
case "include":
include = CfgXmlHelper.ClassCacheIncludeConvertFrom(classCacheElement.Value);
break;
}
}
while (classCacheElement.MoveToNextAttribute());
}
}
public void ReadXml(XPathNavigator node, XmlResolver resolver)
{
if (node.NodeType == XPathNodeType.Element) {
if (node.MoveToFirstAttribute()) {
do {
switch (node.LocalName) {
case "media-type":
this.MediaType = node.Value;
break;
case "boundary":
this.Boundary = node.Value;
break;
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
if (node.MoveToChild(XPathNodeType.Element)) {
XPathHttpMultipartItem currentItem = null;
do {
if (node.NamespaceURI == XPathHttpClient.Namespace) {
switch (node.LocalName) {
case "header":
if (currentItem == null) {
currentItem = new XPathHttpMultipartItem();
}
currentItem.Headers.Add(node.GetAttribute("name", ""), node.GetAttribute("value", ""));
break;
case "body":
if (currentItem == null) {
currentItem = new XPathHttpMultipartItem();
}
currentItem.Body = new XPathHttpBody();
currentItem.Body.ReadXml(node, resolver);
this.Items.Add(currentItem);
currentItem = null;
break;
}
}
} while (node.MoveToNext(XPathNodeType.Element));
node.MoveToParent();
}
}
}
private void Parse(XPathNavigator eventElement)
{
XPathNavigator eventClone = eventElement.Clone();
eventElement.MoveToFirstAttribute();
type = CfgXmlHelper.ListenerTypeConvertFrom(eventElement.Value);
XPathNodeIterator listenersI = eventClone.SelectDescendants(XPathNodeType.Element, false);
while (listenersI.MoveNext())
{
listeners.Add(new ListenerConfiguration(listenersI.Current, type));
}
}
string GetAssemblyVersion(XPathNavigator nav)
{
if(nav.HasAttributes)
nav.MoveToFirstAttribute();
do
{
if (Utilities.Compare(nav.LocalName, "version"))
return nav.Value;
} while (nav.MoveToNextAttribute( ));
return string.Empty;
}
public static Dictionary<string, string> GetAttributes(XPathNavigator navigator)
{
if (!navigator.MoveToFirstAttribute())
throw new DeserializationException("Node has no attributes: " + navigator.Name);
Dictionary<string, string> attributes = new Dictionary<string, string>();
do
{
attributes.Add(navigator.Name, navigator.Value);
} while (navigator.MoveToNextAttribute());
navigator.MoveToParent();
return attributes;
}
public SettingsMappingWhatContents (XPathNavigator nav, SettingsMappingWhatOperation operation)
{
_operation = operation;
if (nav.HasAttributes) {
nav.MoveToFirstAttribute ();
_attributes.Add (nav.Name, nav.Value);
while (nav.MoveToNextAttribute ())
_attributes.Add (nav.Name, nav.Value);
}
}
public void ReadXml(XPathNavigator node) {
if (node.MoveToFirstAttribute()) {
do {
if (String.IsNullOrEmpty(node.NamespaceURI)) {
switch (node.LocalName) {
case "method":
switch (node.Value) {
case "xml":
this.Method = XmlSerializationOptions.Methods.Xml;
break;
case "html":
this.Method = XmlSerializationOptions.Methods.Html;
break;
case "xhtml":
this.Method = XmlSerializationOptions.Methods.XHtml;
break;
case "text":
this.Method = XmlSerializationOptions.Methods.Text;
break;
}
break;
default:
break;
}
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
if (node.MoveToFirstChild()) {
do {
if (node.NodeType == XPathNodeType.Element || node.NodeType == XPathNodeType.Text) {
this.Content = node.Clone();
break;
}
} while (node.MoveToNext());
node.MoveToParent();
}
}
private static void WriteAttributes(TextWriter writer, XPathNavigator nav, string leadIn)
{
nav.MoveToFirstAttribute();
do
{
writer.Write(leadIn);
writer.Write(nav.Name);
writer.Write(Constants.Space);
writer.WriteLine(nav.Value);
} while (nav.MoveToNextAttribute());
nav.MoveToParent();
}
/// <summary>
/// Parses the "version" node represented by a <see cref="XPathNavigator"/> object.
/// </summary>
/// <param name="xpathNav">The <see cref="XPathNavigator"/> object containing the "version" node.</param>
/// <returns>An instance of the <see cref="AppVersionInfo"/> class.</returns>
/// <exception cref="VersionCheckingException"></exception>
private static AppVersionInfo ParseAppTag(XPathNavigator xpathNav)
{
string name = null;
Version version = null;
string informationalVersion = null;
string description = null;
string downloadUrl = null;
if (xpathNav.MoveToFirstAttribute())
{
do
{
switch (xpathNav.Name)
{
case "name":
name = xpathNav.Value;
break;
case "version":
try
{
version = new Version(xpathNav.Value);
}
catch (Exception ex)
{
throw new VersionCheckingException(VersioningResources.Error_VersionInformation_InvalidVersionsFile_InvalidVersionAttribute, ex);
}
break;
case "informationalVersion":
informationalVersion = xpathNav.Value;
break;
case "description":
description = xpathNav.Value;
break;
case "downloadUrl":
downloadUrl = xpathNav.Value;
break;
}
} while (xpathNav.MoveToNextAttribute());
}
if (version == null)
throw new VersionCheckingException(VersioningResources.Error_VersionInformation_VersionAttributeNotFound);
return new AppVersionInfo(name, version, informationalVersion, description, downloadUrl);
}
private void AddAttributeList(XPathNavigator nav, ArrayList attrs)
{
if (nav.HasAttributes)
{
nav.MoveToFirstAttribute();
do
{
if (!attrs.Contains(nav.Name))
{
attrs.Add(nav.Name);
}
}
while (nav.MoveToNextAttribute());
nav.MoveToParent();
}
}
internal static void TraceContext(XPathNavigator context) {
string output = "(null)";
if (context != null) {
context = context.Clone ();
switch (context.NodeType) {
case XPathNodeType.Element:
output = string.Format("<{0}:{1}", context.Prefix, context.LocalName);
for (bool attr = context.MoveToFirstAttribute(); attr; attr = context.MoveToNextAttribute()) {
output += string.Format(CultureInfo.InvariantCulture, " {0}:{1}={2}", context.Prefix, context.LocalName, context.Value);
}
output += ">";
break;
default:
break;
}
}
WriteLine(output);
}
private void Parse(XPathNavigator listenerElement)
{
if (listenerElement.MoveToFirstAttribute())
{
do
{
switch (listenerElement.Name)
{
case "class":
if (listenerElement.Value.Trim().Length == 0)
throw new HibernateConfigException("Invalid listener element; the attribute <class> must be assigned with no empty value");
clazz = listenerElement.Value;
break;
case "type":
type = CfgXmlHelper.ListenerTypeConvertFrom(listenerElement.Value);
break;
}
}
while (listenerElement.MoveToNextAttribute());
}
}
private void Parse(XPathNavigator collectionCacheElement)
{
if (collectionCacheElement.MoveToFirstAttribute())
{
do
{
switch (collectionCacheElement.Name)
{
case "collection":
if (collectionCacheElement.Value.Trim().Length == 0)
throw new HibernateConfigException("Invalid collection-cache element; the attribute <collection> must be assigned with no empty value");
collection = collectionCacheElement.Value;
break;
case "usage":
usage = EntityCacheUsageParser.Parse(collectionCacheElement.Value);
break;
case "region":
region = collectionCacheElement.Value;
break;
}
}
while (collectionCacheElement.MoveToNextAttribute());
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="component">The XPath navigator containing the
/// component's configuration information</param>
internal BuildComponentInfo(XPathNavigator component)
{
StringBuilder sb = new StringBuilder();
FileVersionInfo fvi;
XPathNavigator item;
string asmPath, attrValue;
isValid = true;
// Load the configuration information from the node
try
{
attrValue = component.GetAttribute("type", String.Empty);
if(String.IsNullOrEmpty(attrValue))
{
isValid = false;
typeName = "??";
invalidReason = "Missing type name attribute";
}
else
typeName = attrValue;
// If no ID, use the type name
attrValue = component.GetAttribute("id", String.Empty);
if(!String.IsNullOrEmpty(attrValue))
id = attrValue;
else
id = typeName;
attrValue = component.GetAttribute("assembly", String.Empty);
if(String.IsNullOrEmpty(attrValue))
{
isValid = false;
assemblyPath = "??";
invalidReason = "Missing assembly attribute";
}
else
{
assemblyPath = attrValue;
// Try to get copyright and version information
asmPath = BuildComponentManager.ResolveComponentPath(
assemblyPath);
if(File.Exists(asmPath))
{
fvi = FileVersionInfo.GetVersionInfo(asmPath);
version = new Version(fvi.FileVersion);
copyright = fvi.LegalCopyright;
}
else
{
version = new Version("0.0.0.0");
copyright = "?? - Unable to locate assembly";
isValid = false;
invalidReason = "The build component assembly " +
asmPath + " could not be found";
}
}
// If no description use the type name and assembly path
item = component.SelectSingleNode("description");
if(item != null)
description = item.Value.Trim();
else
description = typeName + ", " + assemblyPath;
if(component.SelectSingleNode("hidden") != null)
isHidden = true;
item = component.SelectSingleNode("configureMethod");
if(item != null)
{
attrValue = item.GetAttribute("name", String.Empty);
if(!String.IsNullOrEmpty(attrValue))
configureMethod = attrValue;
}
// The default configuration is wrapped in a <component> tag
item = component.SelectSingleNode("defaultConfiguration");
// We need to retain custom attributes on the component as well
// as the standard id, type, and assembly attributes.
sb.Append("<component");
if(component.MoveToFirstAttribute())
{
do
{
sb.AppendFormat(" {0}=\"{1}\"", component.Name,
component.Value);
} while(component.MoveToNextAttribute());
component.MoveToParent();
}
sb.AppendFormat(CultureInfo.InvariantCulture,
">\r\n{0}\r\n</component>",
(item == null) ? String.Empty : item.InnerXml);
defaultConfig = sb.ToString();
item = component.SelectSingleNode("insert");
if(item != null)
referencePosition = new ComponentPosition(item);
else
referencePosition = new ComponentPosition();
item = component.SelectSingleNode("insertConceptual");
if(item != null)
conceptualPosition = new ComponentPosition(item);
else
conceptualPosition = new ComponentPosition();
List<string> deps = new List<string>();
foreach(XPathNavigator dep in component.Select(
"dependencies/component"))
{
attrValue = dep.GetAttribute("id", String.Empty);
if(!String.IsNullOrEmpty(attrValue))
deps.Add(attrValue);
}
dependencies = new ReadOnlyCollection<string>(deps);
}
catch(Exception ex)
{
isValid = false;
invalidReason = ex.Message;
}
}
/// <summary>
/// Deep copy the subtree that is rooted at this navigator's current position to output. If the current
/// item is an element, copy all in-scope namespace nodes.
/// </summary>
private void CopyNode(XPathNavigator navigator) {
XPathNodeType nodeType;
int depthStart = this.depth;
Debug.Assert(navigator != null);
while (true) {
if (StartCopy(navigator, this.depth == depthStart)) {
nodeType = navigator.NodeType;
Debug.Assert(nodeType == XPathNodeType.Element, "StartCopy should return true only for Element nodes.");
// Copy attributes
if (navigator.MoveToFirstAttribute()) {
do {
StartCopy(navigator, false);
}
while (navigator.MoveToNextAttribute());
navigator.MoveToParent();
}
// Copy namespaces in document order (navigator returns them in reverse document order)
CopyNamespaces(navigator, (this.depth - 1 == depthStart) ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.Local);
StartElementContentUnchecked();
// If children exist, move down to next level
if (navigator.MoveToFirstChild())
continue;
EndCopy(navigator, (this.depth - 1) == depthStart);
}
// No children
while (true) {
if (this.depth == depthStart) {
// The entire subtree has been copied
return;
}
if (navigator.MoveToNext()) {
// Found a sibling, so break to outer loop
break;
}
// No siblings, so move up to previous level
navigator.MoveToParent();
EndCopy(navigator, (this.depth - 1) == depthStart);
}
}
}
public void AttributeNavigation ()
{
document.LoadXml ("<foo bar='baz' quux='quuux' />");
navigator = document.DocumentElement.CreateNavigator ();
Assert.AreEqual (XPathNodeType.Element, navigator.NodeType, "#1");
Assert.AreEqual ("foo", navigator.Name, "#2");
Assert.IsTrue (navigator.MoveToFirstAttribute (), "#3");
Assert.AreEqual (XPathNodeType.Attribute, navigator.NodeType, "#4");
Assert.AreEqual ("bar", navigator.Name, "#5");
Assert.AreEqual ("baz", navigator.Value, "#6");
Assert.IsTrue (navigator.MoveToNextAttribute (), "#7");
Assert.AreEqual (XPathNodeType.Attribute, navigator.NodeType, "#8");
Assert.AreEqual ("quux", navigator.Name, "#9");
Assert.AreEqual ("quuux", navigator.Value, "#10");
}
/// <summary>
/// If navigator is positioned on an attribute, move to the next attribute node. If there are no more
/// attributes, move to the first content node. If navigator is positioned on a content node, move to
/// the next content node. If there are no more attributes and content nodes, return null.
/// Otherwise, return navigator.
/// </summary>
public static bool MoveToNextAttributeContent(XPathNavigator navigator) {
if (navigator.NodeType == XPathNodeType.Attribute) {
if (!navigator.MoveToNextAttribute()) {
navigator.MoveToParent();
if (!navigator.MoveToFirstChild()) {
// No children, so reposition on original attribute
navigator.MoveToFirstAttribute();
while (navigator.MoveToNextAttribute())
;
return false;
}
}
return true;
}
return navigator.MoveToNext();
}
/// <summary>
/// Move to navigator's first attribute node. If no attribute's exist, move to the first content node.
/// If no content nodes exist, return null. Otherwise, return navigator.
/// </summary>
public static bool MoveToFirstAttributeContent(XPathNavigator navigator) {
if (!navigator.MoveToFirstAttribute())
return navigator.MoveToFirstChild();
return true;
}
public override bool MoveToAttribute(string name)
{
int depth;
XPathNavigator nav = GetElemNav(out depth);
if (null == nav)
{
return(false);
}
string prefix, localname;
ValidateNames.SplitQName(name, out prefix, out localname);
// watch for a namespace name
bool IsXmlnsNoPrefix = false;
if ((IsXmlnsNoPrefix = (0 == prefix.Length && localname == "xmlns")) ||
(prefix == "xmlns"))
{
if (IsXmlnsNoPrefix)
{
localname = string.Empty;
}
if (nav.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
do
{
if (nav.LocalName == localname)
{
goto FoundMatch;
}
} while (nav.MoveToNextNamespace(XPathNamespaceScope.Local));
}
}
else if (0 == prefix.Length)
{
// the empty prefix always means empty namespaceUri for attributes
if (nav.MoveToAttribute(localname, string.Empty))
{
goto FoundMatch;
}
}
else
{
if (nav.MoveToFirstAttribute())
{
do
{
if (nav.LocalName == localname && nav.Prefix == prefix)
{
goto FoundMatch;
}
} while (nav.MoveToNextAttribute());
}
}
return(false);
FoundMatch:
if (_state == State.InReadBinary)
{
_readBinaryHelper.Finish();
_state = _savedState;
}
MoveToAttr(nav, depth + 1);
return(true);
}
// Copies the current node from the given XPathNavigator to the writer (including child nodes).
public virtual void WriteNode(XPathNavigator navigator, bool defattr)
{
if (navigator == null)
{
throw new ArgumentNullException(nameof(navigator));
}
int iLevel = 0;
navigator = navigator.Clone();
while (true)
{
bool mayHaveChildren = false;
XPathNodeType nodeType = navigator.NodeType;
switch (nodeType)
{
case XPathNodeType.Element:
WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
// Copy attributes
if (navigator.MoveToFirstAttribute())
{
do
{
IXmlSchemaInfo schemaInfo = navigator.SchemaInfo;
if (defattr || (schemaInfo == null || !schemaInfo.IsDefault))
{
WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
// copy string value to writer
WriteString(navigator.Value);
WriteEndAttribute();
}
} while (navigator.MoveToNextAttribute());
navigator.MoveToParent();
}
// Copy namespaces
if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
WriteLocalNamespaces(navigator);
navigator.MoveToParent();
}
mayHaveChildren = true;
break;
case XPathNodeType.Attribute:
// do nothing on root level attribute
break;
case XPathNodeType.Text:
WriteString(navigator.Value);
break;
case XPathNodeType.SignificantWhitespace:
case XPathNodeType.Whitespace:
WriteWhitespace(navigator.Value);
break;
case XPathNodeType.Root:
mayHaveChildren = true;
break;
case XPathNodeType.Comment:
WriteComment(navigator.Value);
break;
case XPathNodeType.ProcessingInstruction:
WriteProcessingInstruction(navigator.LocalName, navigator.Value);
break;
case XPathNodeType.Namespace:
// do nothing on root level namespace
break;
default:
Debug.Assert(false);
break;
}
if (mayHaveChildren)
{
// If children exist, move down to next level
if (navigator.MoveToFirstChild())
{
iLevel++;
continue;
}
else
{
// EndElement
if (navigator.NodeType == XPathNodeType.Element)
{
if (navigator.IsEmptyElement)
{
WriteEndElement();
}
else
{
WriteFullEndElement();
}
}
}
}
// No children
while (true)
{
if (iLevel == 0)
{
// The entire subtree has been copied
return;
}
if (navigator.MoveToNext())
{
// Found a sibling, so break to outer loop
break;
}
// No siblings, so move up to previous level
iLevel--;
navigator.MoveToParent();
// EndElement
if (navigator.NodeType == XPathNodeType.Element)
WriteFullEndElement();
}
}
}
bool IReflectorPersistance.Load(System.Xml.XPath.XPathNavigator r)
{
if (r.NodeType == XPathNodeType.Element)
{
osalot.AssemblyTracker tracker = new osalot.AssemblyTracker();
string location = null;
switch (r.Name)
{
case "Plugins":
bool everokay = false;
bool okay;
for (okay = r.MoveToFirstAttribute(); okay; okay = r.MoveToNextAttribute())
{
everokay = true;
switch (r.Name)
{
case "Location":
location = r.Value;
break;
}
}
if (everokay)
{
r.MoveToParent();
}
everokay = false;
for (okay = r.MoveToFirstChild(); okay; okay = r.MoveToNext())
{
everokay = true;
switch (r.Name)
{
case "System Mask":
tracker.allow_on_system.Add(r.Value);
break;
}
}
if (everokay)
{
r.MoveToParent();
}
if (tracker.allow_on_system.Count == 0)
{
core_common.LoadAssembly(location, tracker);
}
else
{
foreach (String s in tracker.allow_on_system)
{
Match m = Regex.Match(SystemInformation.ComputerName, s);
if (m.Success)
{
core_common.LoadAssembly(location, tracker);
break;
}
}
}
return(true);
}
return(false);
}
return(false);
}
public override string GetAttribute(string name)
{
// reader allows calling GetAttribute, even when positioned inside attributes
XPathNavigator nav = _nav;
switch (nav.NodeType)
{
case XPathNodeType.Element:
break;
case XPathNodeType.Attribute:
nav = nav.Clone();
if (!nav.MoveToParent())
{
return(null);
}
break;
default:
return(null);
}
string prefix, localname;
ValidateNames.SplitQName(name, out prefix, out localname);
if (0 == prefix.Length)
{
if (localname == "xmlns")
{
return(nav.GetNamespace(string.Empty));
}
if ((object)nav == (object)_nav)
{
nav = nav.Clone();
}
if (nav.MoveToAttribute(localname, string.Empty))
{
return(nav.Value);
}
}
else
{
if (prefix == "xmlns")
{
return(nav.GetNamespace(localname));
}
if ((object)nav == (object)_nav)
{
nav = nav.Clone();
}
if (nav.MoveToFirstAttribute())
{
do
{
if (nav.LocalName == localname && nav.Prefix == prefix)
{
return(nav.Value);
}
} while (nav.MoveToNextAttribute());
}
}
return(null);
}
public override bool MoveToAttribute(string name)
{
int num;
string str;
string str2;
XPathNavigator elemNav = this.GetElemNav(out num);
if (elemNav == null)
{
return(false);
}
ValidateNames.SplitQName(name, out str, out str2);
bool flag = false;
if ((flag = (str.Length == 0) && (str2 == "xmlns")) || (str == "xmlns"))
{
if (flag)
{
str2 = string.Empty;
}
if (elemNav.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
do
{
if (elemNav.LocalName == str2)
{
goto Label_00B5;
}
}while (elemNav.MoveToNextNamespace(XPathNamespaceScope.Local));
}
}
else
{
if (str.Length == 0)
{
if (!elemNav.MoveToAttribute(str2, string.Empty))
{
goto Label_00B3;
}
goto Label_00B5;
}
if (elemNav.MoveToFirstAttribute())
{
do
{
if ((elemNav.LocalName == str2) && (elemNav.Prefix == str))
{
goto Label_00B5;
}
}while (elemNav.MoveToNextAttribute());
}
}
Label_00B3:
return(false);
Label_00B5:
if (this.state == State.InReadBinary)
{
this.readBinaryHelper.Finish();
this.state = this.savedState;
}
this.MoveToAttr(elemNav, num + 1);
return(true);
}
public override bool MoveToNextAttribute()
{
switch (this.state)
{
case State.Content:
return(this.MoveToFirstAttribute());
case State.Attribute:
if (XPathNodeType.Attribute != this.nav.NodeType)
{
XPathNavigator other = this.nav.Clone();
if (other.MoveToParent())
{
if (!other.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
return(false);
}
if (other.IsSamePosition(this.nav))
{
other.MoveToParent();
if (!other.MoveToFirstAttribute())
{
return(false);
}
this.nav.MoveTo(other);
return(true);
}
XPathNavigator navigator2 = other.Clone();
while (other.MoveToNextNamespace(XPathNamespaceScope.Local))
{
if (other.IsSamePosition(this.nav))
{
this.nav.MoveTo(navigator2);
return(true);
}
navigator2.MoveTo(other);
}
}
return(false);
}
return(this.nav.MoveToNextAttribute());
case State.AttrVal:
this.depth--;
this.state = State.Attribute;
if (this.MoveToNextAttribute())
{
break;
}
this.depth++;
this.state = State.AttrVal;
return(false);
case State.InReadBinary:
this.state = this.savedState;
if (this.MoveToNextAttribute())
{
this.readBinaryHelper.Finish();
return(true);
}
this.state = State.InReadBinary;
return(false);
default:
return(false);
}
this.nodeType = XmlNodeType.Attribute;
return(true);
}
/// <summary>
/// Copy the navigator subtree to the raw writer.
/// </summary>
private void CopyNode(XPathNavigator nav) {
XPathNodeType nodeType;
int iLevel = 0;
while (true) {
if (CopyShallowNode(nav)) {
nodeType = nav.NodeType;
if (nodeType == XPathNodeType.Element) {
// Copy attributes
if (nav.MoveToFirstAttribute()) {
do {
CopyShallowNode(nav);
}
while (nav.MoveToNextAttribute());
nav.MoveToParent();
}
// Copy namespaces in document order (navigator returns them in reverse document order)
XPathNamespaceScope nsScope = (iLevel == 0) ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.Local;
if (nav.MoveToFirstNamespace(nsScope)) {
CopyNamespaces(nav, nsScope);
nav.MoveToParent();
}
this.xwrt.StartElementContent();
}
// If children exist, move down to next level
if (nav.MoveToFirstChild()) {
iLevel++;
continue;
}
else {
// EndElement
if (nav.NodeType == XPathNodeType.Element)
this.xwrt.WriteEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI);
}
}
// No children
while (true) {
if (iLevel == 0) {
// The entire subtree has been copied
return;
}
if (nav.MoveToNext()) {
// Found a sibling, so break to outer loop
break;
}
// No siblings, so move up to previous level
iLevel--;
nav.MoveToParent();
// EndElement
if (nav.NodeType == XPathNodeType.Element)
this.xwrt.WriteFullEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI);
}
}
}
public override string GetAttribute(string name)
{
string str;
string str2;
XPathNavigator nav = this.nav;
switch (nav.NodeType)
{
case XPathNodeType.Element:
break;
case XPathNodeType.Attribute:
nav = nav.Clone();
if (nav.MoveToParent())
{
break;
}
return(null);
default:
return(null);
}
ValidateNames.SplitQName(name, out str, out str2);
if (str.Length == 0)
{
if (str2 == "xmlns")
{
return(nav.GetNamespace(string.Empty));
}
if (nav == this.nav)
{
nav = nav.Clone();
}
if (nav.MoveToAttribute(str2, string.Empty))
{
return(nav.Value);
}
}
else
{
if (str == "xmlns")
{
return(nav.GetNamespace(str2));
}
if (nav == this.nav)
{
nav = nav.Clone();
}
if (nav.MoveToFirstAttribute())
{
do
{
if ((nav.LocalName == str2) && (nav.Prefix == str))
{
return(nav.Value);
}
}while (nav.MoveToNextAttribute());
}
}
return(null);
}
private void IsDescendant (XPathNavigator nav)
{
XPathNavigator tmp = nav.Clone ();
XPathNodeIterator iter = nav.Select ("//e");
iter.MoveNext ();
Assert.IsTrue (nav.MoveTo (iter.Current), "#1");
Assert.IsTrue (nav.MoveToFirstAttribute (), "#2");
Assert.AreEqual ("attr", nav.Name, "#3");
Assert.AreEqual ("", tmp.Name, "#4");
Assert.IsTrue (tmp.IsDescendant (nav), "#5");
Assert.IsTrue (!nav.IsDescendant (tmp), "#6");
tmp.MoveToFirstChild ();
Assert.AreEqual ("a", tmp.Name, "#7");
Assert.IsTrue (tmp.IsDescendant (nav), "#8");
Assert.IsTrue (!nav.IsDescendant (tmp), "#9");
tmp.MoveTo (iter.Current);
Assert.AreEqual ("e", tmp.Name, "#10");
Assert.IsTrue (tmp.IsDescendant (nav), "#11");
Assert.IsTrue (!nav.IsDescendant (tmp), "#12");
}
protected XPathNavigator MatchNode(XPathNavigator current, IQuery query)
{
XPathNavigator context;
if (current != null)
{
context = query.MatchNode(current);
if (context != null)
{
if (_opnd.ReturnType() == XPathResultType.Number)
{
if (_opnd.getName() == Querytype.Constant)
{
XPathNavigator result = current.Clone();
int i = 0;
if (query.getName() == Querytype.Child)
{
result.MoveToParent();
result.MoveToFirstChild();
while (true)
{
if (((ChildrenQuery)query).matches(result))
{
i++;
if (current.IsSamePosition(result))
{
if (XmlConvert.ToXPathDouble(_opnd.getValue(current, null)) == i)
{
return(context);
}
else
{
return(null);
}
}
}
if (!result.MoveToNext())
{
return(null);
}
}
}
if (query.getName() == Querytype.Attribute)
{
result.MoveToParent();
result.MoveToFirstAttribute();
while (true)
{
if (((AttributeQuery)query).matches(result))
{
i++;
}
if (current.IsSamePosition(result))
{
if (XmlConvert.ToXPathDouble(_opnd.getValue(current, null)) == i)
{
return(context);
}
else
{
return(null);
}
}
if (!result.MoveToNextAttribute())
{
return(null);
}
}
}
}
else
{
setContext(context.Clone());
XPathNavigator result = advance();
while (result != null)
{
if (result.IsSamePosition(current))
{
return(context);
}
result = advance();
}
}
}
if (_opnd.ReturnType() == XPathResultType.NodeSet)
{
_opnd.setContext(current);
if (_opnd.advance() != null)
{
return(context);
}
else
{
return(null);
}
}
if (_opnd.ReturnType() == XPathResultType.Boolean)
{
if (noPosition)
{
if ((bool)_opnd.getValue(current, null))
{
return(context);
}
return(null);
}
setContext(context.Clone());
XPathNavigator result = advance();
while (result != null)
{
if (result.IsSamePosition(current))
{
return(context);
}
result = advance();
}
return(null);
}
if (_opnd.ReturnType() == XPathResultType.String)
{
if (_opnd.getValue(context, null).ToString().Length > 0)
{
return(context);
}
else
{
return(null);
}
}
}
else
{
return(null);
}
}
return(null);
}
public void ReadXml(XPathNavigator node) {
bool movedToDocEl = false;
if (node.NodeType == XPathNodeType.Root)
movedToDocEl = node.MoveToChild(XPathNodeType.Element);
if (node.NamespaceURI == XPathSmtpClient.Namespace
&& node.LocalName == "message") {
if (node.MoveToFirstAttribute()) {
do {
if (String.IsNullOrEmpty(node.NamespaceURI)) {
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
if (node.MoveToChild(XPathNodeType.Element)) {
do {
if (node.NamespaceURI == XPathSmtpClient.Namespace) {
switch (node.LocalName) {
case "from":
this.From = new XPathMailAddress();
this.From.ReadXml(node);
break;
case "reply-to": {
XPathMailAddress address = new XPathMailAddress();
address.ReadXml(node);
this.ReplyTo.Add(address);
}
break;
case "sender":
this.Sender = new XPathMailAddress();
this.Sender.ReadXml(node);
break;
case "to": {
XPathMailAddress address = new XPathMailAddress();
address.ReadXml(node);
this.To.Add(address);
}
break;
case "cc": {
XPathMailAddress address = new XPathMailAddress();
address.ReadXml(node);
this.CC.Add(address);
}
break;
case "bcc": {
XPathMailAddress address = new XPathMailAddress();
address.ReadXml(node);
this.Bcc.Add(address);
}
break;
case "subject":
this.Subject = node.Value;
break;
case "body":
this.Body = new XPathMailBody();
this.Body.ReadXml(node);
break;
default:
break;
}
}
} while (node.MoveToNext(XPathNodeType.Element));
node.MoveToParent();
}
}
if (movedToDocEl)
node.MoveToParent();
}
private void XmlElementWithAttributes (XPathNavigator nav)
{
nav.MoveToFirstChild ();
AssertNavigator ("#1", nav, XPathNodeType.Element, "", "img", "", "img", "", true, false, true);
Assert.IsTrue (!nav.MoveToNext ());
Assert.IsTrue (!nav.MoveToPrevious ());
Assert.IsTrue (nav.MoveToFirstAttribute ());
AssertNavigator ("#2", nav, XPathNodeType.Attribute, "", "src", "", "src", "foo.png", false, false, false);
Assert.IsTrue (!nav.MoveToFirstAttribute ()); // On attributes, it fails.
Assert.IsTrue (nav.MoveToNextAttribute ());
AssertNavigator ("#3", nav, XPathNodeType.Attribute, "", "alt", "", "alt", "image Fooooooo!", false, false, false);
Assert.IsTrue (!nav.MoveToNextAttribute ());
Assert.IsTrue (nav.MoveToParent ());
AssertNavigator ("#4", nav, XPathNodeType.Element, "", "img", "", "img", "", true, false, true);
Assert.IsTrue (nav.MoveToAttribute ("alt", ""));
AssertNavigator ("#5", nav, XPathNodeType.Attribute, "", "alt", "", "alt", "image Fooooooo!", false, false, false);
Assert.IsTrue (!nav.MoveToAttribute ("src", "")); // On attributes, it fails.
Assert.IsTrue (nav.MoveToParent ());
Assert.IsTrue (nav.MoveToAttribute ("src", ""));
AssertNavigator ("#6", nav, XPathNodeType.Attribute, "", "src", "", "src", "foo.png", false, false, false);
nav.MoveToRoot ();
AssertNavigator ("#7", nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);
}
public void ReadXml(XPathNavigator node)
{
bool movedToDocEl = false;
if (node.NodeType == XPathNodeType.Root) {
movedToDocEl = node.MoveToChild(XPathNodeType.Element);
}
if (node.NamespaceURI == XPathHttpClient.Namespace
&& node.LocalName == "request") {
if (node.NodeType == XPathNodeType.Element) {
if (node.MoveToFirstAttribute()) {
do {
switch (node.LocalName) {
case "method":
this.Method = node.Value;
break;
case "href":
this.Href = new Uri(node.Value, UriKind.Absolute);
break;
case "status-only":
this.StatusOnly = node.ValueAsBoolean;
break;
case "username":
this.Username = node.Value;
break;
case "password":
this.Password = node.Value;
break;
case "auth-method":
this.AuthMethod = node.Value;
break;
case "send-authorization":
this.SendAuthorization = node.ValueAsBoolean;
break;
case "override-media-type":
this.OverrideMediaType = node.Value;
break;
case "follow-redirect":
this.FollowRedirect = node.ValueAsBoolean;
break;
case "timeout":
this.Timeout = node.ValueAsInt;
break;
default:
break;
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
if (node.MoveToChild(XPathNodeType.Element)) {
do {
if (node.NamespaceURI == XPathHttpClient.Namespace) {
switch (node.LocalName) {
case "header":
this.Headers.Add(node.GetAttribute("name", ""), node.GetAttribute("value", ""));
break;
case "body":
this.Body = new XPathHttpBody();
this.Body.ReadXml(node, this.Resolver);
break;
case "multipart":
this.Multipart = new XPathHttpMultipart();
this.Multipart.ReadXml(node, this.Resolver);
break;
default:
break;
}
}
} while (node.MoveToNext(XPathNodeType.Element));
node.MoveToParent();
}
}
}
if (movedToDocEl) {
node.MoveToParent();
}
}
/// <summary>
/// Function analyzes children of the node recursively
/// </summary>
/// <param name="nodeNavigator">current node whose children schould be analyzed</param>
/// <param name="groupName">currently created sequence of group names to this node</param>
/// <param name="parameterName">name of the compared parameter</param>
/// <param name="dictionaryEntry">entry for currently analyzed xml doc</param>
/// <param name="temp">temporary entry for the parameter to be filled</param>
public void AnalyzeNodeChildren(XPathNavigator nodeNavigator, string groupName, string parameterName, KeyValuePair<string, XPathDocument> dictionaryEntry, Dictionary<ParameterID, Dictionary<String, object>> temp)
{
nodeNavigator.MoveToFirstChild();
do
{
//----comparing param's attributes-----------------
if (nodeNavigator.HasChildren)
{
// This is a group
StringBuilder groupNameNewSB = new StringBuilder();
nodeNavigator.MoveToAttribute("NAME", "");
groupNameNewSB.Append(groupName);
if (groupName != "")
{
groupNameNewSB.Append(".");
}
groupNameNewSB.Append(nodeNavigator.Value);
nodeNavigator.MoveToParent();
AnalyzeNodeChildren(nodeNavigator, groupNameNewSB.ToString(), parameterName, dictionaryEntry, temp);
}
else
{
nodeNavigator.MoveToFirstAttribute();
do
{
switch (nodeNavigator.Name)
{
case "NAME":
break;
case "HINT":
break;
case "TYPE":
break;
case "VALUE": // this can be done better....... but anyways , let's continue :)
//paramValue = Convert.ToDouble(thisNavigator.ValueAsDouble);
object paramValue = null;
double doubleValue;
bool paramIsString = false;
if (!Double.TryParse(nodeNavigator.Value, NumberStyles.Number, CultureInfo.InvariantCulture/*CultureInfo.CreateSpecificCulture("en-GB")*/, out doubleValue))
{
paramValue = nodeNavigator.Value;
paramIsString = true;
}
//------- move to attribute doesn't work backwards (no idea why)
// update: because it cannot go from attribute to attribute with the use of
//MoveToAttribute method (in this case only MoveToNextAttribute can be used)
nodeNavigator.MoveToParent();
nodeNavigator.MoveToFirstChild();
nodeNavigator.MoveToAttribute("NAME", "");
//if no match with desired name 'break;' and go to the next one
if (!nodeNavigator.Value.Contains(parameterName))
{
nodeNavigator.MoveToParent();
nodeNavigator.MoveToFirstChild();
nodeNavigator.MoveToAttribute("VALUE", "");
break;
}
#region Adding parameter to temp
//....add( (fileName, Concatenated String <groupName + , + parameterName>), parameterValue)
if (paramIsString)
{
// For this I could have written a function :)
Dictionary<string, object> tempDictionary = new Dictionary<string, object>();
///if this parameter entry already exists, then only add it's difference entry in its dictionary
if (temp.TryGetValue(new ParameterID(nodeNavigator.Value, groupName, true), out tempDictionary))
//if (temp.ContainsKey(new parameterID(thisNavigator.Value, groupName)))
{
tempDictionary.Add(dictionaryEntry.Key, paramValue);
}
else
{
tempDictionary = new Dictionary<string, object>();
tempDictionary.Add(dictionaryEntry.Key, paramValue);
temp.Add(new ParameterID(nodeNavigator.Value, groupName, true), tempDictionary);
//(DictionaryEntry.Key, groupName + ", " + thisNavigator.Value), paramValue);
}
}
else
{
Dictionary<string, object> tempDictionary = new Dictionary<string, object>();
///if this parameter entry already exists, then only add it's difference entry in its dictionary
if (temp.TryGetValue(new ParameterID(nodeNavigator.Value, groupName, false), out tempDictionary))
//if (temp.ContainsKey(new parameterID(thisNavigator.Value, groupName)))
{
tempDictionary.Add(dictionaryEntry.Key, doubleValue);
}
else
{
tempDictionary = new Dictionary<string, object>();
tempDictionary.Add(dictionaryEntry.Key, doubleValue);
temp.Add(new ParameterID(nodeNavigator.Value, groupName, false), tempDictionary);
//(DictionaryEntry.Key, groupName + ", " + thisNavigator.Value), paramValue);
}
}
#endregion
//again - doesn't work backwards
nodeNavigator.MoveToParent();
nodeNavigator.MoveToFirstChild();
nodeNavigator.MoveToAttribute("VALUE", "");
break;
case "LEVEL":
break;
default:
break;
}
} while (nodeNavigator.MoveToNextAttribute());
nodeNavigator.MoveToParent();
}
} while (nodeNavigator.MoveToNext());//iteration on params
nodeNavigator.MoveToParent();
}
public override bool MoveToNextAttribute()
{
switch (_state)
{
case State.Content:
return(MoveToFirstAttribute());
case State.Attribute:
{
if (XPathNodeType.Attribute == _nav.NodeType)
{
return(_nav.MoveToNextAttribute());
}
// otherwise it is on a namespace... namespace are in reverse order
Debug.Assert(XPathNodeType.Namespace == _nav.NodeType);
XPathNavigator nav = _nav.Clone();
if (!nav.MoveToParent())
{
return(false); // shouldn't happen
}
if (!nav.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
return(false); // shouldn't happen
}
if (nav.IsSamePosition(_nav))
{
// this was the last one... start walking attributes
nav.MoveToParent();
if (!nav.MoveToFirstAttribute())
{
return(false);
}
// otherwise we are there
_nav.MoveTo(nav);
return(true);
}
else
{
XPathNavigator prev = nav.Clone();
while (true)
{
if (!nav.MoveToNextNamespace(XPathNamespaceScope.Local))
{
Debug.Fail("Couldn't find Namespace Node! Should not happen!");
return(false);
}
if (nav.IsSamePosition(_nav))
{
_nav.MoveTo(prev);
return(true);
}
prev.MoveTo(nav);
}
// found previous namespace position
}
}
case State.AttrVal:
_depth--;
_state = State.Attribute;
if (!MoveToNextAttribute())
{
_depth++;
_state = State.AttrVal;
return(false);
}
_nodeType = XmlNodeType.Attribute;
return(true);
case State.InReadBinary:
_state = _savedState;
if (!MoveToNextAttribute())
{
_state = State.InReadBinary;
return(false);
}
_readBinaryHelper.Finish();
return(true);
default:
return(false);
}
}
public void Fill (XPathNavigator nav)
{
if (nav.MoveToFirstAttribute ()) {
ProcessAttribute (nav);
while (nav.MoveToNextAttribute ()) {
ProcessAttribute (nav);
}
// move back to original position
nav.MoveToParent ();
}
}
public static void WriteNode(this XmlWriter writer, XPathNavigator navigator, bool defattr)
{
if (navigator == null)
{
throw new ArgumentNullException("navigator");
}
int iLevel = 0;
navigator = navigator.Clone();
while (true)
{
bool mayHaveChildren = false;
XPathNodeType nodeType = navigator.NodeType;
switch (nodeType)
{
case XPathNodeType.Element:
writer.WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
// Copy attributes
if (navigator.MoveToFirstAttribute())
{
do
{
writer.WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
// copy string value to writer
writer.WriteString(navigator.Value);
writer.WriteEndAttribute();
} while (navigator.MoveToNextAttribute());
navigator.MoveToParent();
}
// Copy namespaces
if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
writer.WriteLocalNamespaces(navigator);
navigator.MoveToParent();
}
mayHaveChildren = true;
break;
case XPathNodeType.Attribute:
// do nothing on root level attribute
break;
case XPathNodeType.Text:
writer.WriteString(navigator.Value);
break;
case XPathNodeType.SignificantWhitespace:
case XPathNodeType.Whitespace:
writer.WriteWhitespace(navigator.Value);
break;
case XPathNodeType.Root:
mayHaveChildren = true;
break;
case XPathNodeType.Comment:
writer.WriteComment(navigator.Value);
break;
case XPathNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(navigator.LocalName, navigator.Value);
break;
case XPathNodeType.Namespace:
// do nothing on root level namespace
break;
default:
Debug.Fail("Unmatched state in switch");
break;
}
if (mayHaveChildren)
{
// If children exist, move down to next level
if (navigator.MoveToFirstChild())
{
iLevel++;
continue;
}
else
{
// EndElement
if (navigator.NodeType == XPathNodeType.Element)
{
if (navigator.IsEmptyElement)
{
writer.WriteEndElement();
}
else
{
writer.WriteFullEndElement();
}
}
}
}
// No children
while (true)
{
if (iLevel == 0)
{
// The entire subtree has been copied
return;
}
if (navigator.MoveToNext())
{
// Found a sibling, so break to outer loop
break;
}
// No siblings, so move up to previous level
iLevel--;
navigator.MoveToParent();
// EndElement
if (navigator.NodeType == XPathNodeType.Element)
{
writer.WriteFullEndElement();
}
}
}
}