/// <summary>
/// Implements the following function
/// number max(node-set)
/// </summary>
/// <param name="iterator"></param>
/// <returns></returns>
public double max(XPathNodeIterator iterator)
{
double max, t;
if (iterator.Count == 0)
{
return Double.NaN;
}
try
{
iterator.MoveNext();
max = XmlConvert.ToDouble(iterator.Current.Value);
while (iterator.MoveNext())
{
t = XmlConvert.ToDouble(iterator.Current.Value);
max = (t > max) ? t : max;
}
}
catch
{
return Double.NaN;
}
return max;
}
/// <summary>
/// Implements the following function
/// number min(node-set)
/// </summary>
/// <param name="iterator"></param>
/// <returns></returns>
public double min(XPathNodeIterator iterator)
{
double min, t;
if (iterator.Count == 0)
{
return Double.NaN;
}
try
{
iterator.MoveNext();
min = XmlConvert.ToDouble(iterator.Current.Value);
while (iterator.MoveNext())
{
t = XmlConvert.ToDouble(iterator.Current.Value);
min = (t < min) ? t : min;
}
}
catch
{
return Double.NaN;
}
return min;
}
/// <summary>
/// Implements the following function
/// string date2:min(node-set)
/// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-min.xml
/// </summary>
/// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
public string min(XPathNodeIterator iterator)
{
TimeSpan min, t;
if (iterator.Count == 0)
{
return "";
}
try
{
iterator.MoveNext();
min = XmlConvert.ToTimeSpan(iterator.Current.Value);
while (iterator.MoveNext())
{
t = XmlConvert.ToTimeSpan(iterator.Current.Value);
min = (t < min) ? t : min;
}
}
catch (FormatException)
{
return "";
}
return XmlConvert.ToString(min);
}
internal DebuggerOptions(XPathNodeIterator iter)
{
while (iter.MoveNext ()) {
switch (iter.Current.Name) {
case "File":
file = iter.Current.Value;
break;
case "InferiorArgs":
append_array (ref inferior_args, iter.Current.Value);
break;
case "JitArguments":
append_array (ref jit_arguments, iter.Current.Value);
break;
case "WorkingDirectory":
WorkingDirectory = iter.Current.Value;
break;
case "MonoPrefix":
MonoPrefix = iter.Current.Value;
break;
case "MonoPath":
MonoPath = iter.Current.Value;
break;
default:
throw new InternalError ();
}
}
if (inferior_args == null)
inferior_args = new string [0];
}
/// <summary>
/// Implements the following function
/// number avg(node-set)
/// </summary>
/// <param name="iterator"></param>
/// <returns>The average of all the value of all the nodes in the
/// node set</returns>
/// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
public double avg(XPathNodeIterator iterator)
{
double sum = 0;
int count = iterator.Count;
if (count == 0)
{
return Double.NaN;
}
try
{
while (iterator.MoveNext())
{
sum += XmlConvert.ToDouble(iterator.Current.Value);
}
}
catch (FormatException)
{
return Double.NaN;
}
return sum / count;
}
/// <summary>
/// Implements an optimized algorithm for the following function
/// node-set difference(node-set, node-set)
/// Uses document identification and binary search,
/// based on the fact that a node-set is always in document order.
/// </summary>
/// <param name="nodeset1">An input nodeset</param>
/// <param name="nodeset2">Another input nodeset</param>
/// <returns>The those nodes that are in the node set
/// passed as the first argument that are not in the node set
/// passed as the second argument.</returns>
/// <author>Dimitre Novatchev</author>
private XPathNodeIterator difference2(XPathNodeIterator nodeset1, XPathNodeIterator nodeset2)
{
List<Pair> arDocs = new List<Pair>();
List<XPathNavigator> arNodes2 = new List<XPathNavigator>(nodeset2.Count);
while (nodeset2.MoveNext())
{
arNodes2.Add(nodeset2.Current.Clone());
}
auxEXSLT.findDocs(arNodes2, arDocs);
XPathNavigatorIterator enlResult = new XPathNavigatorIterator();
while (nodeset1.MoveNext())
{
XPathNavigator currNode = nodeset1.Current;
if (!auxEXSLT.findNode(arNodes2, arDocs, currNode))
enlResult.Add(currNode.Clone());
}
enlResult.Reset();
return enlResult;
}
public CreateLimitationForm(string strXPathRoot, string strName, XPathNodeIterator xpIterator, bool bAttribute,
System.Collections.Specialized.StringCollection astrPreviousConstraints)
{
InitializeComponent();
m_astrPreviousConstraints = astrPreviousConstraints;
this.textBoxXPath.Text = strXPathRoot;
this.textBoxName.Text = strName;
while ((xpIterator != null) && xpIterator.MoveNext())
{
string strValue = xpIterator.Current.Value;
if (!m_strIteratorValues.Contains(strValue))
m_strIteratorValues.Add(strValue);
}
if (bAttribute)
radioButtonSpecificValue.Checked = true;
else
radioButtonPresenceOnly.Checked = true;
// only enabled on subsequent executions
radioButtonPreviousConstraint.Enabled = (m_astrPreviousConstraints.Count > 0);
helpProvider.SetHelpString(checkedListBox, Properties.Resources.checkedListBoxHelp);
helpProvider.SetHelpString(flowLayoutPanelConstraintType, Properties.Resources.flowLayoutPanelConstraintTypeHelp);
}
public static XPathNodeIterator FilterNodes(XPathNodeIterator nodeset, string xpath)
{
try
{
while (nodeset.MoveNext())
{
var nav = nodeset.Current;
var manager = new XmlNamespaceManager(nav.NameTable);
nav.MoveToFollowing(XPathNodeType.Element);
foreach (var ns in nav.GetNamespacesInScope(XmlNamespaceScope.All))
{
manager.AddNamespace(ns.Key, ns.Value);
}
var result = nav.Evaluate(xpath, manager);
if (result is XPathNodeIterator) {
return (XPathNodeIterator)result;
} else {
XmlDocument doc = new XmlDocument();
doc.LoadXml("<result expression=\"" + xpath + "\">" + result.ToString() + "</result>");
return (XPathNodeIterator)doc.DocumentElement.CreateNavigator().Evaluate("/result");
}
}
}
catch (Exception ex)
{
return ex.ToXPathNodeIterator();
}
return nodeset;
}
/// <summary>
/// Implements an optimized algorithm for the following function
/// node-set difference(node-set, node-set)
/// Uses document identification and binary search,
/// based on the fact that a node-set is always in document order.
/// </summary>
/// <param name="nodeset1">An input nodeset</param>
/// <param name="nodeset2">Another input nodeset</param>
/// <returns>The those nodes that are in the node set
/// passed as the first argument that are not in the node set
/// passed as the second argument.</returns>
/// <author>Dimitre Novatchev</author>
private XPathNodeIterator difference2(XPathNodeIterator nodeset1, XPathNodeIterator nodeset2)
{
ArrayList arDocs = new ArrayList();
ArrayList arNodes2 = new ArrayList(nodeset2.Count);
while(nodeset2.MoveNext())
{
arNodes2.Add(nodeset2.Current.Clone());
}
auxEXSLT.findDocs(arNodes2, arDocs);
ExsltNodeList enlResult = new ExsltNodeList();
while(nodeset1.MoveNext())
{
XPathNavigator currNode = nodeset1.Current;
if(!auxEXSLT.findNode(arNodes2, arDocs, currNode) )
enlResult.Add(currNode.Clone());
}
return ExsltCommon.ExsltNodeListToXPathNodeIterator(enlResult);
}
public static string GetWsdlUrl(string referencePath)
{
string url = string.Empty;
if (!string.IsNullOrEmpty(referencePath))
{
XPathDocument xDoc = new XPathDocument(referencePath);
XPathNavigator xNav = xDoc.CreateNavigator();
string xpathExpression;
if (referencePath.Contains(Messages.MSG_D_SERV_REF))
{
xpathExpression = @"ReferenceGroup/Metadata/MetadataFile[MetadataType='Wsdl']/@SourceUrl";
}
else
{
xpathExpression = @"DiscoveryClientResultsFile/Results/DiscoveryClientResult[@referenceType='System.Web.Services.Discovery.ContractReference']/@url";
}
System.Xml.XPath.XPathNodeIterator xIter = xNav.Select(xpathExpression);
if (xIter.MoveNext())
{
url = xIter.Current.TypedValue.ToString();
}
}
return(url);
}
public void CoreFunctionNodeSetPosition ()
{
expression = navigator.Compile("position()");
iterator = navigator.Select("/foo");
AssertEquals ("0", navigator.Evaluate ("position()").ToString ());
AssertEquals ("0", navigator.Evaluate (expression, null).ToString ());
AssertEquals ("0", navigator.Evaluate (expression, iterator).ToString ());
iterator = navigator.Select("/foo/*");
AssertEquals ("0", navigator.Evaluate (expression, iterator).ToString ());
iterator.MoveNext();
AssertEquals ("1", navigator.Evaluate (expression, iterator).ToString ());
iterator.MoveNext ();
AssertEquals ("2", navigator.Evaluate (expression, iterator).ToString ());
iterator.MoveNext ();
AssertEquals ("3", navigator.Evaluate (expression, iterator).ToString ());
}
protected void UpdateSampleValue(XPathNodeIterator xpIterator, DataGridViewRow theRow)
{
if (xpIterator.MoveNext())
{
XPathNavigator nav = xpIterator.Current;
UpdateExampleDataColumns(theRow, nav.Value);
}
}
public ElongRegexEpression()
{
XPathNavigator navigator = RegexOperation.GetXPathNavigatorByPath(CommonOperation.GetConfigValueByKey(Constant.CCTRIPPATH));
nodeIterator = navigator.Select(Constant.CREGEXEXPRESSION);
nodeIterator.MoveNext();
}
static XPathNavigator[] ConvertIteratorToArray(XPathNodeIterator iterator) {
XPathNavigator[] result = new XPathNavigator[iterator.Count];
for (int i = 0; i < result.Length; i++) {
iterator.MoveNext();
result[i] = iterator.Current.Clone();
}
return (result);
}
void ProcessAssemblies (LinkContext context, XPathNodeIterator iterator)
{
while (iterator.MoveNext ()) {
AssemblyDefinition assembly = GetAssembly (context, GetFullName (iterator.Current));
ProcessTypes (assembly, iterator.Current.SelectChildren ("type", _ns));
ProcessNamespaces (assembly, iterator.Current.SelectChildren ("namespace", _ns));
}
}
public XPathArrayIterator(XPathNodeIterator nodeIterator)
{
this.list = new ArrayList();
while (nodeIterator.MoveNext())
{
this.list.Add(nodeIterator.Current.Clone());
}
}
// get an array of nodes matching an XPath expression
public static XPathNavigator[] ConvertNodeIteratorToArray (XPathNodeIterator iterator) {
XPathNavigator[] result = new XPathNavigator[iterator.Count];
for (int i = 0; i < result.Length; i++) {
iterator.MoveNext();
result[i] = iterator.Current.Clone();
// clone is required or all entries will equal Current!
}
return(result);
}
public ExceptionManagerSetting(XPathNodeIterator iter)
{
if (iter.MoveNext())
{
this.EventLogType = LogTypeParser(XmlHelper.GetNavAttr(iter.Current,"eventlogtype"));
this.m_publishlog = (XmlHelper.GetNavAttr(iter.Current,"publishlog")=="on");
this.m_publishlogdb = (XmlHelper.GetNavAttr(iter.Current,"publishlogdb")=="on");
}
}
public CoreStringtables(XPathNodeIterator iter)
{
LocaleSetMap map = new LocaleSetMap(null);
if (iter.MoveNext())
{
map.Init(XmlHelper.Select("localeset", iter.Current));
}
this.m_localeSets = map;
}
public MailSetting(XPathNodeIterator iter)
{
if (iter.MoveNext())
{
this.m_smtpserver = XmlHelper.GetNavAttr(iter.Current,"smtpserver");
this.m_mailhistory = (XmlHelper.GetNavAttr(iter.Current,"mailhistory")=="on");
this.m_mailfaillog = (XmlHelper.GetNavAttr(iter.Current,"mailfaillog")=="on");
this.m_charset = XmlHelper.GetNavAttr(iter.Current,"charset");
}
}
public object @duration(XPathNodeIterator arg)
{
if (ExtensionObjectConvert.IsEmpty(arg)) {
return ExtensionObjectConvert.EmptyIterator;
}
arg.MoveNext();
return XmlConvert.ToString(XmlConvert.ToTimeSpan(arg.Current.Value));
}
public SecuritySetting(XPathNodeIterator iter)
{
if (iter.MoveNext())
{
this.m_loginpage = XmlHelper.GetNavAttr(iter.Current,"loginpage");
this.m_enable = (XmlHelper.GetNavAttr(iter.Current,"enable").ToLower()=="true");
this.m_resourceneedauthorize = (XmlHelper.GetNavAttr(iter.Current,"resourceneedauthorize").ToLower()=="true");
this.m_encryptionkey = XmlHelper.GetNavAttr(iter.Current,"encryptionkey");
}
}
public object @float(XPathNodeIterator arg)
{
if (ExtensionObjectConvert.IsEmpty(arg)) {
return ExtensionObjectConvert.EmptyIterator;
}
arg.MoveNext();
return XmlConvert.ToSingle(arg.Current.Value);
}
public XmlNode GetCraigslistJobDetails( XPathNodeIterator input )
{
input.MoveNext();
var body = input.Current.OuterXml;
var resultDocument = new XDocument();
var resultElement = body.GetDetails();
resultDocument.Add( resultElement );
var result = resultDocument.ToXmlDocument().FirstChild;
return result;
}
/// <summary>
/// Adds a <see cref="XPathNodeIterator"/> containing a set of navigators to add.
/// </summary>
/// <param name="iterator">The set of navigators to add. Each one is cloned automatically.</param>
public void Add(XPathNodeIterator iterator)
{
if (_position != -1)
throw new InvalidOperationException(
SR.XPathNavigatorIterator_CantAddAfterMove);
while (iterator.MoveNext())
{
_navigators.Add(iterator.Current.Clone());
}
}
internal void Add(XPathNodeIterator iter)
{
while (iter.MoveNext())
{
SeekableXPathNavigator current = iter.Current as SeekableXPathNavigator;
if (current == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.Unexpected, System.ServiceModel.SR.GetString("QueryMustBeSeekable")));
}
this.Add(current);
}
}
//=================================================================================================
public string get_value( string xsXmlPath )
{
moIt=moPath.Select( xsXmlPath ) ;
if( moIt.MoveNext() )
{
return moIt.Current.Value ;
}
else
{
return "";
}
}
void ProcessNamespaces (AssemblyDefinition assembly, XPathNodeIterator iterator)
{
while (iterator.MoveNext ()) {
string fullname = GetFullName (iterator.Current);
foreach (TypeDefinition type in assembly.MainModule.Types) {
if (type.Namespace != fullname)
continue;
MarkAndPreserveAll (type);
}
}
}
/// <summary>
/// Implements the following function
/// node-set distinct(node-set)
/// </summary>
/// <param name="nodeset">The input nodeset</param>
/// <returns>Returns the nodes in the nodeset whose string value is
/// distinct</returns>
public static XPathNodeIterator distinct(XPathNodeIterator nodeset){
ExsltNodeList nodelist = new ExsltNodeList();
while(nodeset.MoveNext()){
if(!nodelist.ContainsValue(nodeset.Current.Value)){
nodelist.Add(nodeset.Current.Clone());
}
}
return ExsltCommon.ExsltNodeListToXPathNodeIterator(nodelist);
}
private static void CleanAttributes(XPathNodeIterator xPathIt)
{
string temp;
if (xPathIt.Count > 0)
{
while (xPathIt.MoveNext())
{
temp = xPathIt.Current.Value + " - " + xPathIt.CurrentPosition;
xPathIt.Current.SetValue("");
xPathIt.Current.CreateAttribute(String.Empty, "nil", String.Empty, "true");
}
}
}
/// <summary>
/// Override method that performs the actual property setting from a Navigator result.
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <param name="context"></param>
protected override void DoBindComponent(object component, object data, PDFDataContext context)
{
System.Xml.XPath.XPathExpression expr = this.GetExpression(data, context);
if (data is System.Xml.XPath.XPathNodeIterator)
{
data = ((System.Xml.XPath.XPathNodeIterator)data).Current;
}
System.Xml.XPath.XPathNavigator nav = (System.Xml.XPath.XPathNavigator)data;
if (null == this.Converter)
{
var iterator = nav.Select(expr);
if (this.Property.PropertyType == typeof(XPathNavigator))
{
this.Property.SetValue(component, iterator.Current);
}
else
{
this.Property.SetValue(component, iterator);
}
}
else
{
System.Xml.XPath.XPathNodeIterator itter = nav.Select(expr);
if (itter.CurrentPosition < 0)
{
itter.MoveNext();
}
string value = itter.Current.Value;
object converted = this.Converter(value, this.Property.PropertyType, System.Globalization.CultureInfo.CurrentCulture);
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "Setting property '" + this.Property.Name + "' with the XPath binding expression '" + expr.Expression + "' to value '" + ((null == value) ? "NULL" : value) + "'");
}
this.Property.SetValue(component, converted, null);
}
}
internal XPathNavigator PeekNext()
{
XPathNodeIterator xpathNodeIterator = this.Clone();
return((!xpathNodeIterator.MoveNext()) ? null : xpathNodeIterator.Current);
}
public override bool MoveNextCore()
{
return(iter.MoveNext());
}
internal XPathNavigator PeekNext()
{
XPathNodeIterator i = Clone();
return(i.MoveNext() ? i.Current : null);
}
internal override XPathNavigator advance()
{
if (_eLast == null)
{
XPathNavigator temp = null;
_eLast = m_qyInput.advance();
if (_eLast == null)
{
return(null);
}
while (_eLast != null)
{
_eLast = _eLast.Clone();
temp = _eLast;
_eLast = m_qyInput.advance();
if (!temp.IsDescendant(_eLast))
{
break;
}
}
_eLast = temp;
}
while (true)
{
if (_first)
{
_first = false;
if (_eLast.NodeType == XPathNodeType.Attribute || _eLast.NodeType == XPathNodeType.Namespace)
{
_eLast.MoveToParent();
if (_fMatchName)
{
_qy = _eLast.SelectDescendants(m_Name, m_URN, false);
}
else
{
_qy = _eLast.SelectDescendants(m_Type, false);
}
}
else
{
while (true)
{
if (!_eLast.MoveToNext())
{
if (!_eLast.MoveToParent())
{
_first = true;
return(null);
}
}
else
{
break;
}
}
if (_fMatchName)
{
_qy = _eLast.SelectDescendants(m_Name, m_URN, true);
}
else
{
_qy = _eLast.SelectDescendants(m_Type, true);
}
}
}
if (_qy.MoveNext())
{
_position++;
m_eNext = _qy.Current;
return(m_eNext);
}
else
{
_first = true;
}
}
}
private void EditCand_Load(object sender, EventArgs e)
{
doc = new XPathDocument(FILE_NAME);
nav = doc.CreateNavigator();
// Compile a standard XPath expression
expr = nav.Compile("/config/voto/@puesto");
iterator = nav.Select(expr);
// Iterate on the node set
comboBox1.Items.Clear();
try
{
while (iterator.MoveNext())
{
XPathNavigator nav2 = iterator.Current.Clone();
comboBox1.Items.Add(nav2.Value);
comboBox1.SelectedIndex = 0;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
//save old title
oldTitle = comboBox1.Text;
}
