Compile() public method

public Compile ( string xpath ) : XPathExpression
xpath string
return XPathExpression
        /// <summary>
        /// Récupère la valeur de l'attribut du noeud recherché dans le fichier de configuration
        /// </summary>
        /// <param name="xPathString">Expression XPath de recherche du noeud</param>
        /// <param name="attribute">Attribut à rechercher</param>
        /// <returns>Une ArrayList contenant la liste des attributs recherchés</returns>
        public ArrayList GetAttributes(string xPathString, string attribute)
        {
            // Initilisation des variables
                    XPathNodeIterator xpathNodeIterator;
                    XPathExpression expr;

                    ArrayList attributes = new ArrayList();

                    // Parcours du fichier XML
                    try
                    {
                           xpathNavigator = xpathDoc.CreateNavigator();
                           expr = xpathNavigator.Compile(xPathString);
                           xpathNodeIterator = xpathNavigator.Select(expr);

                           while (xpathNodeIterator.MoveNext())
                           {
                                  // On récupère l'attribut
                                  attributes.Add(xpathNodeIterator.Current.GetAttribute(attribute, ""));
                           }
                    }
                    catch (Exception e)
                    {
                    }

                    return attributes;
        }
 public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
 {
     string str = XPathMessageFunction.ToString(args[0]);
     string xpath = string.Format(CultureInfo.InvariantCulture, "/s11:Envelope/s11:Header/*[@s11:actor='{0}'] | /s12:Envelope/s12:Header/*[@s12:role='{1}']", new object[] { str, str });
     XPathExpression expr = docContext.Compile(xpath);
     expr.SetContext((XmlNamespaceManager) xsltContext);
     return docContext.Evaluate(expr);
 }
Example #3
0
 public string GetValue(string xPathString)
 {
     xpathNavigator = xpathDoc.CreateNavigator();
     XPathExpression expr = xpathNavigator.Compile(xPathString);
     XPathNodeIterator xpathNodeIterator = xpathNavigator.Select(expr);
     xpathNodeIterator.MoveNext();
     return xpathNodeIterator.Current.Value;
 }
Example #4
0
        static XPathNodeIterator Select(string expression, XPathNavigator source, params XPathVariable[] variables)
		{
			var expr = source.Compile(expression);
			var context = new DynamicContext();
			foreach (var variable in variables)
				context.AddVariable(variable.Name, variable.Value);
			expr.SetContext(context);
			return source.Select(expr);
		}
 public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
 {
     if (this.expr == null)
     {
         XPathExpression expression = docContext.Compile("(sm:header()/wsa10:FaultTo | sm:header()/wsaAugust2004:FaultTo)[1]");
         expression.SetContext((XmlNamespaceManager) new XPathMessageContext());
         this.expr = expression;
     }
     return docContext.Evaluate(this.expr);
 }
 public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
 {
     if (this.expr == null)
     {
         XPathExpression expression = docContext.Compile("(/s11:Envelope/s11:Body | /s12:Envelope/s12:Body)[1]");
         expression.SetContext(XPathMessageFunction.Namespaces);
         this.expr = expression;
     }
     return docContext.Evaluate(this.expr);
 }
Example #7
0
		/// <summary>
		/// Retrieves a cached compiled expression, or a newly compiled one.
		/// </summary>
		private static XPathExpression GetCompiledExpression(string expression, XPathNavigator source)
		{
			XPathExpression expr;

			if (!Cache.TryGetValue(expression, out expr))
			{
				// No double checks. At most we will compile twice. No big deal.			  
				expr = source.Compile(expression);
				Cache[expression] = expr;
			}

			return expr.Clone();
		}
Example #8
0
        private void Form1_Load(object sender, EventArgs e)
        {
            String path = @"..\..\..\data\categories.xml";
            categories = new XPathDocument(path);
            nav = categories.CreateNavigator();
            var expr = nav.Compile("//*");
            XPathNodeIterator iter = nav.Select(expr);
            String category = null;
            List<TreeNode> subcats = new List<TreeNode>() ;
            while (iter.MoveNext())
            {
                if(iter.Current.Name == "cat")
                {
                    if(subcats.Count != 0)
                    {
                        TreeNode cat_node = new TreeNode(category, subcats.ToArray());
                        trv_categories.Nodes.Add(cat_node);
                        subcats.Clear();
                    }
                    category = iter.Current.Value;
                }
                else if(iter.Current.Name == "subcat")
                {
                    subcats.Add(new TreeNode(iter.Current.Value));
                }
            }

            path = @"..\..\..\data\";
            synonyms = new Dictionary<string, List<string>>();
            StreamReader reader = new StreamReader(path+"synonyms.txt", Encoding.UTF8);
            while (!reader.EndOfStream)
            {
                String line = reader.ReadLine();
                if (line.Length <= 0)
                    continue;
                line = line.Trim();
                List<String> syms = line.Split(':','،',',').ToList<String>();
                for (int i = 0; i < syms.Count; i++)
                    syms[i] = syms[i].Trim();
                String key = syms[0];
                syms.RemoveAll(s => s.Length <= 0);
                syms.RemoveAt(0);
                if (synonyms.ContainsKey(key))
                    synonyms[key].Concat(syms);
                else
                    synonyms.Add(key, syms);
            }
        }
        /// <summary>
        /// Evaluates an XPath expression in a newly created context, making additional parameters available to the expression.
        /// </summary>
        /// <param name="nav">
        /// Navigator indicating the current node; if <c>null</c>, a dummy navigator is used.
        /// </param>
        /// <param name="xpathExpr">XPath expression to evaluate.</param>
        /// <param name="param">
        /// Values to be available while evaluating the expression as <c>$paramN</c>, where N is the
        /// index within this array.
        /// </param>
        /// <returns>The result of evaluating the expression</returns>
        public static object Evaluate(XPathNavigator nav, string xpathExpr, params object[] param)
        {
            Checker.NotNull(xpathExpr, "xpathExpr");

            nav = EnsureNavigator(nav);

            var expr = nav.Compile(xpathExpr);

            var context = new TriflesXPathContext();

            int i = 0;
            foreach (var paramN in param)
            {
                context.AddVariable(XNamespace.None + ("param" + i), paramN);
                i++;
            }

            expr.SetContext(context);
            return nav.Evaluate(expr);
        }
        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        {
            string actor = ToString(args[0]);
            string e = string.Format(CultureInfo.InvariantCulture, "/s11:Envelope/s11:Header/*[@s11:actor='{0}'] | /s12:Envelope/s12:Header/*[@s12:role='{1}']", actor, actor);
            XPathExpression expr = docContext.Compile(e);
            expr.SetContext(xsltContext);
            return docContext.Evaluate(expr);

#if NO
            // PERF, [....], I drafted this implementation before we found out that a bug in the Fx implementation would 
            //               prevent us from constructing an XPathNodeIterator that they would accept.  I'm keeping it
            //               around in the hope that I will be able to use it by M5.4.  If not, it will be deleted.
            
            XPathNavigator basicNav = docContext.Clone();
            SeekableXPathNavigator nav = basicNav as SeekableXPathNavigator;
            if(nav == null)
            {
                nav = new GenericSeekableNavigator(basicNav);
            }
            
            string actor = (string)args[0];
            NodeSequence seq = new NodeSequence();
            XPathNodeIterator result = new NodeSequenceIterator(seq);
            
            nav.MoveToRoot();
            if(!nav.MoveToFirstChild())
            {
                return result;
            }

            if(nav.LocalName != "Envelope")
            {
                return result;
            }
            
            if(nav.NamespaceURI == XPathMessageContext.S11NS)
            {
                // Move to Header
                if(nav.MoveToFirstChild() && nav.LocalName == "Header" && nav.NamespaceURI == XPathMessageContext.S11NS)
                {
                    // Move to first Header block
                    if(nav.MoveToFirstChild())
                    {
                        // Iterate over header blocks
                        do
                        {
                            if(nav.MoveToAttribute("actor", XPathMessageContext.S11NS))
                            {
                                if(nav.Value == actor)
                                {
                                    seq.Add(nav);
                                }
                                nav.MoveToParent();
                            }
                                    
                        } while(nav.MoveToNext());
                    }
                }
            }
            else if(nav.NamespaceURI == XPathMessageContext.S12NS)
            {
                // Move to Header
                if(nav.MoveToFirstChild() && nav.LocalName == "Header" && nav.NamespaceURI == XPathMessageContext.S12NS)
                {
                    // Move to first Header block
                    if(nav.MoveToFirstChild())
                    {
                        // Iterate over header blocks
                        do
                        {
                            if(nav.MoveToAttribute("role", XPathMessageContext.S12NS))
                            {
                                if(nav.Value == actor)
                                {
                                    seq.Add(nav);
                                }
                                nav.MoveToParent();
                            }
                                    
                        } while(nav.MoveToNext());
                    }
                }
            }

            return result;
#endif
        }
	    private int CalculateDrain(XPathNavigator nav, int force)
	    {
	        XPathExpression xprDV;
            // Calculate the Spell's Drain for the current Force.
	        xprDV = nav.Compile(_strDV.Replace("F", force.ToString()).Replace("/", " div "));
	        decimal decDV = Convert.ToDecimal(nav.Evaluate(xprDV)?.ToString());
	        decDV = Math.Floor(decDV);
	        int intDV = Convert.ToInt32(decDV);
	        // Drain cannot be lower than 2.
	        if (intDV < 2)
	            intDV = 2;
	        return intDV;
	    }
Example #12
0
 /// <summary>
 /// Prepares the Xpath navigator to improve performance for GetNextId().
 /// </summary>
 private void PrepareIdNavigator()
 {
     m_navigator = m_dictionary.CreateNavigator();
     m_expression = m_navigator.Compile(m_basePath);
     m_expression.AddSort(m_XPathId, XmlSortOrder.Descending, XmlCaseOrder.None, String.Empty, XmlDataType.Number);
 }
 public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
 {
     if (this.expr == null)
     {
         XPathExpression e = docContext.Compile("(sm:header()/wsa10:From | sm:header()/wsaAugust2004:From)[1]");
         e.SetContext(new XPathMessageContext());
         this.expr = e;
     }
     return docContext.Evaluate(this.expr);
 }
Example #14
0
        // Need to be implemented separately
        #endregion

        #region Public Methods
        public virtual void UpdateState(string name)
        {
            List<string> tempList = null;
            switch (name)
            {
                case "Initial":
                case "Multiline":
                case "Singleline":
                case "WholeWord":
                case "CaseSensitive":
                case "StopAfterFirstMatch":
                    tempList = new List<string>();
                    if (CaseSensitive)
                        tempList.Add("Case sensitive");
                    if (Multiline)
                        tempList.Add("Multiline");
                    if (WholeWord)
                        tempList.Add("Whole word");
                    if (Singleline)
                        tempList.Add("Dot as new line");
                    if (StopAfterFirstMatch)
                        tempList.Add("Stop after first match");
                    OptionsSummary = "[";
                    if (tempList.Count == 0)
                    {
                        OptionsSummary += "None";
                    }
                    else
                    {
                        for (int i = 0; i < tempList.Count; i++)
                        {
                            OptionsSummary += tempList[i];
                            if (i < tempList.Count - 1)
                                OptionsSummary += ", ";
                        }
                    }
                    OptionsSummary += "]";

                    if (Multiline)
                        TextBoxStyle = "{StaticResource ExpandedTextbox}";
                    else
                        TextBoxStyle = "";

                    CanReplace = false;

                    break;
                case "UseFileSizeFilter":
                    if (UseFileSizeFilter == FileSizeFilter.Yes)
                    {
                        IsSizeFilterSet = true;
                    }
                    else
                    {
                        IsSizeFilterSet = false;
                    }
                    break;
                case "FileFilters":
                    // Set all properties to correspond to ON value
                    if (FileFilters)
                    {
                        UseFileSizeFilter = FileSizeFilter.No;
                        IncludeBinary = true;
                        IncludeHidden = true;
                        IncludeSubfolder = true;
                        FilePattern = "*";
                        FilePatternIgnore = "";
                        TypeOfFileSearch = FileSearchType.Asterisk;
                        CodePage = -1;
                    }
                    break;
            }

            if (name == "FileFilters" || name == "FilePattern" || name == "IncludeSubfolder" ||
                name == "IncludeHidden" || name == "IncludeBinary" || name == "UseFileSizeFilter"
                || name == "FilePatternIgnore")
            {
                if (FileFilters)
                    FileFiltersSummary = "[All files]";
                else
                {
                    tempList = new List<string>();
                    if (FilePattern != "*")
                        tempList.Add(FilePattern);
                    if (!IncludeSubfolder)
                        tempList.Add("No subfolders");
                    if (!IncludeHidden)
                        tempList.Add("No hidden");
                    if (!IncludeBinary)
                        tempList.Add("No binary");
                    if (!string.IsNullOrEmpty(FilePatternIgnore))
                        tempList.Add("Exclusions");
                    if (UseFileSizeFilter == FileSizeFilter.Yes)
                        tempList.Add("Size");
                    FileFiltersSummary = "[";
                    if (tempList.Count == 0)
                    {
                        FileFiltersSummary += "All files";
                    }
                    else
                    {
                        for (int i = 0; i < tempList.Count; i++)
                        {
                            FileFiltersSummary += tempList[i];
                            if (i < tempList.Count - 1)
                                FileFiltersSummary += ", ";
                        }
                    }

                    FileFiltersSummary += "]";
                }
            }

            //Files found
            if (name == "FileOrFolderPath" || name == "SearchFor" || name == "FilePattern" || name == "FilePatternIgnore")
            {
                FilesFound = false;
            }

            //Change title
            if (name == "FileOrFolderPath" || name == "SearchFor")
            {
                if (string.IsNullOrWhiteSpace(FileOrFolderPath))
                    WindowTitle = "dnGREP";
                else
                    WindowTitle = string.Format("{0} in \"{1}\" - dnGREP", (SearchFor == null ? "Empty" : SearchFor.Replace('\n', ' ').Replace('\r', ' ')), FileOrFolderPath);
            }

            //Change validation
            if (name == "SearchFor" || name == "TypeOfSearch")
            {
                if (string.IsNullOrWhiteSpace(SearchFor))
                {
                    ValidationMessage = "";
                }
                else if (TypeOfSearch == SearchType.Regex)
                {
                    try
                    {
                        Regex regex = new Regex(SearchFor);
                        ValidationMessage = "Regex is OK!";
                    }
                    catch
                    {
                        ValidationMessage = "Regex is not valid!";
                    }
                }
                else if (TypeOfSearch == SearchType.XPath)
                {
                    try
                    {
                        nav = doc.CreateNavigator();
                        XPathExpression expr = nav.Compile(SearchFor);
                        ValidationMessage = "XPath is OK!";
                    }
                    catch
                    {
                        ValidationMessage = "XPath is not valid!";
                    }
                }
                else
                {
                    ValidationMessage = "";
                }
            }

            //Can search
            if (name == "FileOrFolderPath" || name == "CurrentGrepOperation" || name == "SearchFor")
            {
                if (Utils.IsPathValid(FileOrFolderPath) && CurrentGrepOperation == GrepOperation.None &&
                    (!string.IsNullOrEmpty(SearchFor) || settings.Get<bool>(GrepSettings.Key.AllowSearchingForFileNamePattern)))
                {
                    CanSearch = true;
                }
                else
                {
                    CanSearch = false;
                }
                // Refersh buttons
                CommandManager.InvalidateRequerySuggested();
            }

            //Set all files if FileOrFolderPath is a file
            if (name == "FileOrFolderPath")
            {
                if (System.IO.File.Exists(FileOrFolderPath))
                    FileFilters = true;
            }

            //btnSearch.ShowAdvance
            if (name == "CurrentGrepOperation" || name == "Initial")
            {
                if (searchResults.Count > 0)
                {
                    //TODO
                    CanSearchInResults = true;
                    SearchButtonMode = "Split";
                }
                else
                {
                    //TODO
                    CanSearchInResults = false;
                    SearchButtonMode = "Button";
                }
            }

            //searchResults
            searchResults.FolderPath = FileOrFolderPath;

            // btnReplace
            if (name == "FileOrFolderPath" || name == "FilesFound" || name == "CurrentGrepOperation" || name == "SearchFor")
            {
                if (Utils.IsPathValid(FileOrFolderPath) && FilesFound && CurrentGrepOperation == GrepOperation.None &&
                    !string.IsNullOrEmpty(SearchFor))
                {
                    CanReplace = true;
                }
                else
                {
                    CanReplace = false;
                }
            }

            //btnCancel
            if (name == "CurrentGrepOperation")
            {
                if (CurrentGrepOperation != GrepOperation.None)
                {
                    CanCancel = true;
                }
                else
                {
                    CanCancel = false;
                }
            }

            //Search type specific options
            if (name == "TypeOfSearch")
            {
                if (TypeOfSearch == SearchType.XPath)
                {
                    IsCaseSensitiveEnabled = false;
                    IsMultilineEnabled = false;
                    IsSinglelineEnabled = false;
                    IsWholeWordEnabled = false;
                    CaseSensitive = false;
                    Multiline = false;
                    Singleline = false;
                    WholeWord = false;
                }
                else if (TypeOfSearch == SearchType.PlainText)
                {
                    IsCaseSensitiveEnabled = true;
                    IsMultilineEnabled = true;
                    IsSinglelineEnabled = false;
                    IsWholeWordEnabled = true;
                    Singleline = false;
                }
                else if (TypeOfSearch == SearchType.Soundex)
                {
                    IsMultilineEnabled = true;
                    IsCaseSensitiveEnabled = false;
                    IsSinglelineEnabled = false;
                    IsWholeWordEnabled = true;
                    CaseSensitive = false;
                    Singleline = false;
                }
                else if (TypeOfSearch == SearchType.Regex)
                {
                    IsCaseSensitiveEnabled = true;
                    IsMultilineEnabled = true;
                    IsSinglelineEnabled = true;
                    IsWholeWordEnabled = true;
                }
            }

            if (IsProperty(() => SearchFor, name) || IsProperty(() => ReplaceWith, name) || IsProperty(() => FilePattern, name))
            {
                if (BookmarkLibrary.Instance.Bookmarks.Contains(new Bookmark(SearchFor, ReplaceWith, FilePattern, "")))
                    IsBookmarked = true;
                else
                    IsBookmarked = false;
            }
        }
Example #15
0
        public object GetXPathScalar(XPathNavigator xpathnav, string expression, XmlNamespaceManager nsmgr)
        {
            if (xpathnav == null)
            {
                return null;
            }
            var expr = xpathnav.Compile(expression);
            expr.SetContext(nsmgr);

            var result = xpathnav.Evaluate(expr);
            switch (expr.ReturnType)
            {
                case XPathResultType.Number:
                    if (result == null)
                    {
                        return 0;
                    }
                    else
                    {
                        return (double)result;
                    }

                case XPathResultType.Boolean:
                    if (result == null)
                    {
                        return false;
                    }
                    else
                    {
                        return (bool)result;
                    }

                case XPathResultType.String:
                    if (result == null)
                    {
                        return "";
                    }
                    else
                    {
                        return (string)result;
                    }

                case XPathResultType.NodeSet:
                    return xpathnav.Select(expression, nsmgr);

                default:
                    return result;
            }
        }
Example #16
0
 public static XPathNodeIterator SelectNodes(XPathNavigator navigator, string xpath, ref XPathExpression compiledExpression, bool multiThreaded)
 {
     if (navigator == null)
     {
         throw new ArgumentNullException("navigator");
     }
     if (xpath == null)
     {
         throw new ArgumentNullException("xpath");
     }
     XPathExpression expression = compiledExpression;
     if (expression == null)
     {
         expression = navigator.Compile(xpath);
         compiledExpression = expression;
     }
     else if (multiThreaded)
     {
         expression = expression.Clone();
     }
     return navigator.Select(expression);
 }
Example #17
0
        public static void Upgrade26xTov270( XPathNavigator xPathNav )
        {
            //Using the new updating API : http://api.civikey.invenietis.com
            AddEntryToSystemConf( "UpdateServerUrl", "http://api.civikey.invenietis.com/", "11C83441-6818-4A8B-97A0-1761E1A54251", "Update Checker", xPathNav );

            //ADD : AutoBinder
            //<PluginStatus Guid="b63bb144-1c13-4a3b-93bd-ac5233f4f18e" Status="AutomaticStart"></PluginStatus>
            string xPathExp = "//System/PluginStatusCollection";
            XPathNodeIterator iterator = xPathNav.Select( xPathNav.Compile( xPathExp ) );

            iterator.MoveNext();

            iterator.Current.PrependChildElement( String.Empty, "PluginStatus", String.Empty, String.Empty );

            iterator.Current.MoveToFirstChild();

            //we are on the first PluginStatus, which we have just created
            iterator.Current.CreateAttribute( String.Empty, "Guid", String.Empty, "b63bb144-1c13-4a3b-93bd-ac5233f4f18e" );
            iterator.Current.CreateAttribute( String.Empty, "Status", String.Empty, "AutomaticStart" );

            //ADD :
            //<Plugins>
            //  <p guid="f6b5d818-3c04-4a46-ad65-afc5458a394c" version="1.0.0" name="CK.WindowManager.WindowElementBinder">
            //    <data key="SerializableBindings" type="Structured" typeName="CK.WindowManager.WindowElementBinder+SerializableBindings, CK.WindowManager, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">
            //      <Bindings>
            //        <Bind Master="Azerty" Slave="Prediction" Position="Top" />
            //        <Bind Master="Ergonomique" Slave="Prediction" Position="Top" />
            //        <Bind Master="ClickSelector" Slave="AutoClick" Position="Top" />
            //      </Bindings>
            //    </data>
            //  </p>
            //</Plugins>

            xPathExp = "//System/Plugins";
            iterator = xPathNav.Select( xPathNav.Compile( xPathExp ) );

            iterator.MoveNext();

            iterator.Current.PrependChildElement( String.Empty, "p", String.Empty, String.Empty );

            iterator.Current.MoveToFirstChild();
            //We are on the <p> element
            iterator.Current.CreateAttribute( null, "guid", null, "f6b5d818-3c04-4a46-ad65-afc5458a394c" );
            iterator.Current.CreateAttribute( null, "version", null, "1.0.0" );
            iterator.Current.CreateAttribute( null, "name", null, "CK.WindowManager.WindowElementBinder" );

            iterator.Current.PrependChildElement( String.Empty, "data", String.Empty, String.Empty );
            iterator.Current.MoveToFirstChild();
            //We are on the <data> element
            iterator.Current.CreateAttribute( null, "key", null, "SerializableBindings" );
            iterator.Current.CreateAttribute( null, "type", null, "Structured" );
            iterator.Current.CreateAttribute( null, "typeName", null, "CK.WindowManager.WindowElementBinder+SerializableBindings, CK.WindowManager, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" );

            iterator.Current.PrependChildElement( String.Empty, "Bindings", String.Empty, String.Empty );
            iterator.Current.MoveToFirstChild();
            //We are on the <Bindings> element

            iterator.Current.AppendChild( "<Bind Master=\"Azerty\" Slave=\"Prediction\" Position=\"Top\" />" );
            iterator.Current.AppendChild( "<Bind Master=\"Ergonomique\" Slave=\"Prediction\" Position=\"Top\" />" );
            iterator.Current.AppendChild( "<Bind Master=\"ClickSelector\" Slave=\"AutoClick\" Position=\"Top\" />" );
            //iterator.Current.MoveToFirstChild();
            //We are on the <Bind> element
            //iterator.Current.CreateAttribute( null, "Master", null, "Azerty" );
            //iterator.Current.CreateAttribute( null, "Slave", null, "Prediction" );
            //iterator.Current.CreateAttribute( null, "Position", null, "Top" );

            //iterator.Current.InsertElementAfter( String.Empty, "Bind", String.Empty, String.Empty );
            //iterator.Current.MoveToFollowing( "Bind", String.Empty );
            //iterator.Current.CreateAttribute( null, "Master", null, "Ergonomique" );
            //iterator.Current.CreateAttribute( null, "Slave", null, "Prediction" );
            //iterator.Current.CreateAttribute( null, "Position", null, "Top" );

            //iterator.Current.InsertElementAfter( String.Empty, "Bind", String.Empty, String.Empty );
            //iterator.Current.MoveToFollowing( "Bind", String.Empty );
            //iterator.Current.CreateAttribute( null, "Master", null, "ClickSelector" );
            //iterator.Current.CreateAttribute( null, "Slave", null, "AutoClick" );
            //iterator.Current.CreateAttribute( null, "Position", null, "Top" );
        }
 public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
 {
     if (this.expr == null)
     {
         XPathExpression e = docContext.Compile("(/s11:Envelope/s11:Header | /s12:Envelope/s12:Header)[1]");
         e.SetContext(Namespaces);
         this.expr = e;
     }
     return docContext.Evaluate(this.expr);
 }
Example #19
0
        private static void CreateEntryToSystemConf( string key, string value, string pluginId, string pluginName, XPathNavigator xPathNav, ref string xPathExp, ref XPathNodeIterator iterator )
        {
            xPathExp = "//System/Plugins";
            iterator = xPathNav.Select( xPathNav.Compile( xPathExp ) );

            if( iterator.Count == 0 ) //if there is no pluginsData child
            {
                xPathExp = "//System";
                iterator = xPathNav.Select( xPathNav.Compile( xPathExp ) );
                iterator.MoveNext();

                iterator.Current.AppendChildElement( null, "Plugins", null, null );
                iterator.Current.MoveToFirstChild();

                while( iterator.Current.Name != "Plugins" ) iterator.Current.MoveToNext();
            }
            else
            {
                iterator.MoveNext();
            }

            bool pFound = false;
            //Adding the <p>
            if( iterator.Current.MoveToFirstChild() )
            {
                //at least one "<p>" exists
                do
                {
                    if( iterator.Current.GetAttribute( "guid", String.Empty ) == pluginId )
                    {
                        //if the <p> corresponds to the updater data
                        pFound = true;
                        break;
                        //We are on the right <p>
                    }
                } while( iterator.Current.MoveToNext() );

                if( !pFound )
                {
                    iterator.Current.InsertElementAfter( null, "p", null, null );
                    iterator.Current.MoveToNext();
                    iterator.Current.CreateAttribute( null, "guid", null, pluginId );
                    iterator.Current.CreateAttribute( null, "version", null, "1.0.0" );
                    iterator.Current.CreateAttribute( null, "name", null, pluginName );
                }
            }
            else
            {
                //There is nothing in PluginsData, we add the updater's <p>

                iterator.Current.AppendChildElement( null, "p", null, null );
                iterator.Current.MoveToFirstChild();
                iterator.Current.CreateAttribute( null, "guid", null, pluginId );
                iterator.Current.CreateAttribute( null, "version", null, "1.0.0" );
                iterator.Current.CreateAttribute( null, "name", null, pluginName );
                //We are on the right <p>
            }

            //Last step : adding the <data>
            if( iterator.Current.MoveToFirstChild() )
            {
                InsertUpdateElementAfter( iterator, value, key );
            }
            else
            {
                //There are no children yet
                AppendChildUpdateElement( iterator, value, key );
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="iteratorSport"></param>
        /// <returns></returns>
        private IPeriod PeriodPinnacleParse(XPathNavigator matchEventNameNavigator, XPathNodeIterator iteratorBet)
        {
            XPathNavigator _betNameNavigator = iteratorBet.Current.Clone();
            IPeriod _period = new Period();
            // Add period to Match
            //handicap
            XPathExpression exprehandicap;
            exprehandicap = matchEventNameNavigator.Compile("spreads/spread");
            XPathNodeIterator iteratorHandicap = matchEventNameNavigator.Select(exprehandicap);
            //total
            XPathExpression expretotal;
            expretotal = matchEventNameNavigator.Compile("totals/total");
            XPathNodeIterator iteratorTotal = matchEventNameNavigator.Select(expretotal);
            //moneyline
            XPathExpression expremoneyline;
            expremoneyline = matchEventNameNavigator.Compile("moneyLine");
            XPathNodeIterator iteratorMoneyLine = matchEventNameNavigator.Select(expremoneyline);
            while (iteratorHandicap.MoveNext())
            {
                ISpread _spread = SpreadPinnacleParse(iteratorHandicap);
                if (_period.Spreads == null)
                {
                    _period.Spreads = new List<ISpread>();
                }
                _period.Spreads.Add(_spread);
            }

            while (iteratorTotal.MoveNext())
            {
                ITotal _total = TotalPinnacleParse(iteratorTotal);
                if (_period.Totals == null)
                {
                    _period.Totals = new List<ITotal>();
                }
                _period.Totals.Add(_total);

            }

            while (iteratorMoneyLine.MoveNext())
            {
                IMoneyLine _moneyline = MoneyLinePinnacleParse(iteratorMoneyLine);
                if (_period.MoneyLines == null)
                {
                    _period.MoneyLines = new List<IMoneyLine>();
                }
                _period.MoneyLines.Add(_moneyline);
            }

            if (_period.Totals != null && _period.MoneyLines != null && _period.Spreads != null)
                _period.Description = _betNameNavigator.SelectSingleNode("description").Value;

            return _period;
        }
Example #21
0
 private static XPathExpression CreateExpression(XPathNavigator nav, string xpath, XmlNamespaceManager ns)
 {
     XPathExpression expr = nav.Compile(xpath);
     expr.SetContext(ns);
     return expr;
 }
Example #22
0
        public bool IsMatch(XPathNavigator xpn, XmlNamespaceManager xnm)
        {
            if ( xpathExpression == null )
            {
                xpathExpression=xpn.Compile(xpath);
                xpathExpression.SetContext(xnm);
            }

            return xpn.Matches(xpathExpression);

            //			Debug.Assert(e.Name.Equals(name), "IsMatch called for incorrect element!");
            //			// TODO: L: bit messy
            //			return Conditions == null || Conditions.Conditions ==null ||
            //				Conditions.Conditions.Count == 0 || Conditions.MatchesAll(e);
        }
        private XPathNodeIterator CreateIterator(string queryString, XPathNavigator nav)
        {
            XPathExpression query = nav.Compile(queryString);
            XPathNodeIterator iter = nav.Select(query);
            return iter;

        }
Example #24
0
        private void createScenario(XPathNavigator navigator, XmlDocument document)
        {
            // Could move this to its own function if we start to use more.
            exprEvents = navigator.Compile("ChangeEngram | " +
                                           "CloseChatRoom | " +
                                           "Completion_Event | " +
                                           "Create_Event | " +
                                           "DefineEngram | " +
                                           "FlushEvents | " +
                                           "Launch_Event | " +
                                           "Move_Event | " +
                                           "OpenChatRoom | " +
                                           "Reiterate | " +
                                           "RemoveEngram | " +
                                           "Reveal_Event | " +
                                           "Species_Completion_Event | " +
                                           "StateChange_Event | " +
                                           "Transfer_Event");

            // Set up component values
            String cType = "Scenario";
            String cName = "Scenario";
            XPathNavigator navScenario = navigator.SelectSingleNode("/Scenario");
            XPathNavigator navScenarioName = navigator.SelectSingleNode("/Scenario/ScenarioName");
            if (navScenarioName != null)
            {
                cName = navScenarioName.Value;
            }
            navScenario.CreateAttribute(String.Empty, "name", navScenario.NamespaceURI, cName);
            String cDescription = String.Empty;
            // Create component
            createComponent(ProjectConfiguration, document, cType, cName, cDescription);

            // Create parameters
            #region parameters

            createParameter(ProjectConfiguration, document, cName, "Component", "Scenario.Scenario Name", (navigator.SelectSingleNode("Scenario/ScenarioName") == null) ? String.Empty : navigator.SelectSingleNode("Scenario/ScenarioName").Value, String.Empty);
            createParameter(ProjectConfiguration, document, cName, "Component", "Scenario.Description", (navigator.SelectSingleNode("Scenario/Description") == null) ? String.Empty : navigator.SelectSingleNode("Scenario/Description").Value, String.Empty);
            createParameter(ProjectConfiguration, document, cName, "Component", "Scenario.Time To Attack", (navigator.SelectSingleNode("Scenario/TimeToAttack") == null) ? String.Empty : navigator.SelectSingleNode("Scenario/TimeToAttack").Value, String.Empty);
            if (navigator.SelectSingleNode("Scenario/ClientSideAssetTransfer") != null)
            {
                String clientSideAssetTransferValue = navigator.SelectSingleNode("Scenario/ClientSideAssetTransfer").Value;
                Boolean booleanValue = false;
                if (clientSideAssetTransferValue.Equals("0"))
                    booleanValue = false;

                else if (clientSideAssetTransferValue.Equals("1"))
                    booleanValue = true;

                else
                {
                    Boolean result = Boolean.TryParse(clientSideAssetTransferValue, out booleanValue);
                    if (!result)
                        booleanValue = false;
                }

                createParameter(ProjectConfiguration, document, cName, "Component", "Scenario.Allow Asset Transfers", booleanValue.ToString(), String.Empty);
            }
            else
                createParameter(ProjectConfiguration, document, cName, "Component", "Scenario.Allow Asset Transfers", String.Empty, String.Empty);


            #endregion

            // Playfield is required.
            createPlayfield(navigator, document, navigator);
            // LandRegion is optional
            XPathNodeIterator itLandRegions = navigator.Select("/Scenario/LandRegion");
            while (itLandRegions.MoveNext())
            {
                createLandRegion(itLandRegions.Current, document, navigator);
            }
            // ActiveRegion is optional
            XPathNodeIterator itActiveRegions = navigator.Select("/Scenario/ActiveRegion");
            while (itActiveRegions.MoveNext())
            {
                itActiveRegions.Current.CreateAttribute(String.Empty, "name", itActiveRegions.Current.NamespaceURI, itActiveRegions.Current.SelectSingleNode("ID").Value);
                createActiveRegion(itActiveRegions.Current, document, navigator);
            }
            // Team is optional
            XPathNodeIterator itTeams = navigator.Select("/Scenario/Team");
            while (itTeams.MoveNext())
            {
                createTeam(itTeams.Current, document, navigator);
            }
            // DecisionMaker is optional
            XPathNodeIterator itDecisionMakers = navigator.Select("/Scenario/DecisionMaker");
            while (itDecisionMakers.MoveNext())
            {
                itDecisionMakers.Current.CreateAttribute(String.Empty, "name", itDecisionMakers.Current.NamespaceURI, itDecisionMakers.Current.SelectSingleNode("Identifier").Value);
                createDecisionMaker(itDecisionMakers.Current, document, navigator);
            }
            // Network is optional
            XPathNodeIterator itNetworks = navigator.Select("/Scenario/Network");
            while (itNetworks.MoveNext())
            {
                createNetwork(itNetworks.Current, document, navigator);
            }
            // DefineEngram is optional
            XPathNodeIterator itDefineEngrams = navigator.Select("/Scenario/DefineEngram");
            while (itDefineEngrams.MoveNext())
            {
                createEngram(itDefineEngrams.Current, document, navigator);
            }
            // Sensor is optional
            XPathNodeIterator itSensors = navigator.Select("/Scenario/Sensor");
            while (itSensors.MoveNext())
            {
                createSensor(itSensors.Current, document, navigator);
            }
            // Genus
            XPathNodeIterator itGenera = navigator.Select("/Scenario/Genus");
            while (itGenera.MoveNext())
            {
                createGenus(itGenera.Current, document, navigator);
            }
            // Species
            //Int32 speciesNum = 0;
            XPathNodeIterator itSpecies = navigator.Select("/Scenario/Species");
            while (itSpecies.MoveNext())
            {
                itSpecies.Current.CreateAttribute(String.Empty, "name", itSpecies.Current.NamespaceURI, itSpecies.Current.SelectSingleNode("Name").Value);
                createSpecies(itSpecies.Current, document, navigator);
            }

            // Events
            createEvents(navigator.SelectSingleNode("Scenario"), document, navigator);

            // Rule
            XPathNodeIterator itRules = navigator.Select("/Scenario/Rule");
            while (itRules.MoveNext())
            {
                itRules.Current.CreateAttribute(String.Empty, "name", itSpecies.Current.NamespaceURI, itRules.Current.SelectSingleNode("Name").Value);
                createRule(itRules.Current, document, navigator);
            }

            // Score
            XPathNodeIterator itScores = navigator.Select("/Scenario/Score");
            while (itScores.MoveNext())
            {
                itScores.Current.CreateAttribute(String.Empty, "name", itScores.Current.NamespaceURI, itScores.Current.SelectSingleNode("Name").Value);
                createScore(itScores.Current, document, navigator);
            }
        }
Example #25
0
        private static void AddEntryToSystemConf( string key, string value, string pluginId, string pluginName, XPathNavigator xPathNav )
        {
            bool entrySet = false;

            string xPathExp = "//p[@guid='" + pluginId.ToUpper() + "']";
            XPathNodeIterator iterator = xPathNav.Select( xPathNav.Compile( xPathExp ) );
            if( iterator.Count == 1 )
            {
                entrySet = DoUpdateEntryToSystemConf( key, value, entrySet, iterator );
            }//At the end of this if statement, we are either on the right data element, or a the end of the pluginsdata
            else
            {
                xPathExp = "//p[@guid='" + pluginId.ToLower() + "']";
                iterator = xPathNav.Select( xPathNav.Compile( xPathExp ) );
                if( iterator.Count == 1 )
                {
                    entrySet = DoUpdateEntryToSystemConf( key, value, entrySet, iterator );
                }
                else //if the updater entry does not exist, create it
                {
                    CreateEntryToSystemConf( key, value, pluginId, pluginName, xPathNav, ref xPathExp, ref iterator );
                }
            }
        }
        private static ComponentTemplateMetadata FindTemplateComponentMetadata(XPathNavigator nav)
        {
            ComponentTemplateMetadata template = null;

            //search for all references for template components metadata
            string templateType = typeof(ComponentTemplateMetadata).ToString();
            XPathExpression expression = nav.Compile("//Metadata[starts-with(@type, '" + templateType + "')]");
            XPathNavigator templateXmlNode = nav.SelectSingleNode(expression);

            if (templateXmlNode != null)
            {
                string label = templateXmlNode.GetAttribute("Label", String.Empty);
                IOSpec ioSpec = new IOSpec();
                XPathNavigator ioSpecNav = templateXmlNode.SelectSingleNode("IOSpec");
                ioSpec.ReadXml(ioSpecNav.ReadSubtree());

                template = new ComponentTemplateMetadata(ioSpec, label);
            }
            return template;
        }
Example #27
0
        private void EditForm_Load(object sender, System.EventArgs e)
        {
            doc = new XPathDocument(FILE_NAME);
            nav = doc.CreateNavigator();

            // Compile a standard XPath expression

            expr = nav.Compile("/catalog/cd/title");
            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);

                }
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            comboBox1.SelectedIndex = 0;

            //save old title
            oldTitle = comboBox1.Text;
        }
Example #28
0
        internal void Compile(XPathNavigator nav)
        {
            if(Status == XPathSelectorStatus.Start)
            {
                GetXPath(nav);
            }
            if(Status == XPathSelectorStatus.Parsed)
            {
                xpath = nav.Compile(sXpath);
                xpath.SetContext(GetNSManager());

                Status = XPathSelectorStatus.Compiled;
            }
        }
Example #29
0
        /// <summary>
        /// Upgrades the user configuration (from .NET 3.5 to .NET 4.0 and its breaking change - we now need a ContextProfileCollection in the UserConf)
        /// If the userConf, is in a 4.0 version, this method won't do anything
        /// It returns the contextpath found via the userconf, in case the context has been moved or renamed.
        /// Return String.Empty if a contextpath can't be found.
        /// </summary>
        /// <param name="xPathSystemNav"></param>
        /// <returns></returns>
        private static string UpgradeUser35To40( XPathNavigator xPathSystemNav )
        {
            string xPathExp = "//UserProfile";
            XmlDocument xPathDoc;
            XPathNavigator xPathUserNav;

            string userConfPath = String.Empty;
            string contextPath = String.Empty;

            XPathNodeIterator iterator = xPathSystemNav.Select( xPathSystemNav.Compile( xPathExp ) );
            if( iterator.Count > 0 ) //if there is a path to a userConf
            {
                iterator.MoveNext();

                if( iterator.Count > 1 ) //if there are more than one userProfile, find the last one.
                {
                    while( iterator.Current.GetAttribute( "IsLast", "" ) != "True" ) iterator.MoveNext();
                }

                userConfPath = iterator.Current.GetAttribute( "Address", "" );
                if( !String.IsNullOrEmpty( userConfPath ) && File.Exists( userConfPath ) ) //and it exists
                {
                    Console.Out.WriteLine( "Migrating from .NET 3.5 version to .NET 4.0 version..." );
                    xPathDoc = new XmlDocument();
                    xPathDoc.Load( userConfPath );
                    xPathUserNav = xPathDoc.CreateNavigator();
                    xPathExp = "//data[@key='LastContextPath']";
                    XPathNodeIterator userConfIterator = xPathUserNav.Select( xPathUserNav.Compile( xPathExp ) );
                    if( userConfIterator.Count == 1 ) // and we can find a LastContextPath ( -> this is a v3.5 userConf)
                    {
                        userConfIterator.MoveNext();

                        string contextPathTemp = userConfIterator.Current.Value;
                        Uri uri = new Uri( contextPathTemp );

                        if( !String.IsNullOrEmpty( contextPathTemp ) && File.Exists( contextPathTemp ) ) //and that lastContextPath is reachable
                        {
                            contextPath = contextPathTemp; //Return the contextPath.
                            //Remove the LastContextPath tag
                            userConfIterator.Current.DeleteSelf();

                            //and add a ContextProfileCollection ( -> upgrade to v4)
                            xPathUserNav = xPathDoc.CreateNavigator();
                            xPathExp = "//PluginStatusCollection";
                            userConfIterator = xPathUserNav.Select( xPathUserNav.Compile( xPathExp ) );

                            userConfIterator.MoveNext();

                            userConfIterator.Current.InsertElementAfter( "", "ContextProfileCollection", "", "" );
                            userConfIterator.Current.MoveToFollowing( "ContextProfileCollection", "" );
                            userConfIterator.Current.AppendChildElement( "", "ContextProfile", "", "" );
                            userConfIterator.Current.MoveToChild( "ContextProfile", "" );
                            userConfIterator.Current.CreateAttribute( "", "DisplayName", "", "Context" );
                            userConfIterator.Current.CreateAttribute( "", "Uri", "", @"file://" + contextPath.Replace( "\\", "/" ) );

                            xPathDoc.Save( userConfPath );
                            Console.Out.WriteLine( "Migration from .NET 3.5 version to .NET 4.0 version done" );
                        }
                    }
                    else
                    {
                        Console.Out.WriteLine( "Migration from .NET 3.5 version to .NET 4.0 version isn't necessary" );
                    }
                }
                else
                {
                    Console.Out.WriteLine( "Migration from .NET 3.5 version to .NET 4.0 version isn't necessary" );
                }
            }
            return contextPath;
        }
Example #30
-3
        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;

        }