/// <summary> /// Construct DateConfiguration instance from xml element. /// </summary> /// <param name="baseControlConfigurationElement"></param> /// <param name="xmlParser"></param> public DateConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser) : base(baseControlConfigurationElement, xmlParser) { this.MaxValue = xmlParser.ParseDateTime(baseControlConfigurationElement, "@MaxLength", null); this.MinValue = xmlParser.ParseDateTime(baseControlConfigurationElement, "@MinLength", null); this.DefaultDate = xmlParser.ParseEnum<DefaultDateValues>(baseControlConfigurationElement, "@DefaultDate"); }
public SiteMapping(String fileName) { _fileName = fileName; var parser = new XmlParser(); var content = File.Exists(fileName) ? File.ReadAllText(_fileName) : "<entries></entries>"; _xml = parser.Parse(content); }
/// <summary> /// Construct DecimalConfiguration instance from xml element. /// </summary> /// <param name="baseControlConfigurationElement"></param> /// <param name="xmlParser"></param> public DecimalConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser) : base(baseControlConfigurationElement, xmlParser) { XmlElement numbericElement = baseControlConfigurationElement; this.AllowNegative = xmlParser.ParseBoolean(numbericElement, "@AllowNegative", true); this.DecimalPrecision = xmlParser.ParseInt(numbericElement, "@DecimalPrecision", 2); }
public static string[] GetColumnNames(string path, string rootElementName, string rowElementName) { Console.Out.WriteLine("Scanning \"" + path + "\" for input field names..."); using (FileStream file = new FileStream(path, FileMode.Open)) { XmlParser p = new XmlParser(file); p.SkipToElement(rootElementName); Set<string> columnNames = new Set<string>(false); while (true) { p.MoveToElementNode(false); string rowXML = p.OuterXML(rowElementName); if (rowXML == null) break; XmlParser rowP = new XmlParser(rowXML); rowP.MoveToElementNode(true); while (rowP.MoveToElementNode(false) != null) columnNames.Add(rowP.CurrentName); } return columnNames.ToArray(); } }
/// <summary> /// Construct RadioGroupConfiguration instance from xml element. /// </summary> /// <param name="baseControlConfigurationElement"></param> /// <param name="xmlParser"></param> public RadioGroupConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser) : base(baseControlConfigurationElement, xmlParser) { this.Items = new Collection<RadioGroupItemConfiguration>(); XmlNodeList radioConfigurationElements = baseControlConfigurationElement.SelectNodes("p:Item", xmlParser.NamespaceManager); foreach (XmlElement radioConfigurationElement in radioConfigurationElements.Cast<XmlElement>()) this.Items.Add(new RadioGroupItemConfiguration(radioConfigurationElement, xmlParser)); }
/// <summary> /// Construct CheckBoxGroupConfiguration instance from xml element. /// </summary> /// <param name="baseControlConfigurationElement"></param> /// <param name="xmlParser"></param> public CheckBoxGroupConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser) : base(baseControlConfigurationElement, xmlParser) { this.Items = new Collection<CheckBoxGroupItemConfiguration>(); XmlNodeList checkboxConfigurationElements = baseControlConfigurationElement.SelectNodes("p:Item", xmlParser.NamespaceManager); foreach (XmlElement checkboxGroupItemConfigurationElement in checkboxConfigurationElements.Cast<XmlElement>()) this.Items.Add(new CheckBoxGroupItemConfiguration(checkboxGroupItemConfigurationElement, xmlParser)); }
/// <summary> /// Construct BaseLayoutConfiguration instance from xml element. /// </summary> /// <param name="baseLayoutConfigurationElement"></param> /// <param name="xmlParser"></param> protected BaseLayoutConfiguration(XmlElement baseLayoutConfigurationElement, XmlParser xmlParser) { this.HeaderText = xmlParser.ParseString(baseLayoutConfigurationElement, "@HeaderText"); this.Collapsible = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@Collapsible", false); this.Collapsed = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@Collapsed", false); this.EnableBorder = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@EnableBorder", false); this.EnableFrame = xmlParser.ParseBoolean(baseLayoutConfigurationElement, "@EnableFrame", false); }
/// <summary> /// Get last.fm object automatically /// </summary> /// <param name="method"></param> /// <param name="parameters"></param> /// <param name="lastfmObject"></param> /// <param name="type"></param> protected void AutomaticGetObject(string method, RequestParameters parameters, ref object lastfmObject, string type) { var request = new LastfmRequest(method, parameters); var parser = new XmlParser(request.RequestURL); var inner = parser.ConvertToInners().GetInnerByKey(type); var lastfmParser = new LastfmParser(); lastfmObject = lastfmParser.SetObjectPropertiesValues(lastfmObject, inner, Session); }
/// <summary> /// Construct TextBoxConfiguration instance from xml element. /// </summary> /// <param name="baseControlConfigurationElement"></param> /// <param name="xmlParser"></param> public TextBoxConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser) : base(baseControlConfigurationElement, xmlParser) { XmlElement textboxElement = baseControlConfigurationElement; this.MaxLength = xmlParser.ParseInt(textboxElement, "@MaxLength", null); this.MinLength = xmlParser.ParseInt(textboxElement, "@MinLength", null); this.ValidationType = xmlParser.ParseEnum<TextBoxValidationTypes>(textboxElement, "@ValidationType"); }
public void ParseASingleEmptyProgrammerFromAnXmlFile() { var filename = "AcceptanceTests\\SingleEmptyProgrammer.xml"; var parser = new XmlParser(filename); IEnumerable<Programmer> programmer = parser.Parse(); Assert.That(programmer.Single().Name, Is.EqualTo("Bill")); }
/// <summary> /// Overrides <see cref="XmlPacketSegment.Parse"/>, /// parsing the current FinalListPacketSegment. /// </summary> /// <param name="Reader">The packet data reader.</param> /// <param name="Container">The parent packet segment container.</param> /// <param name="parser">The Xml packet parser.</param> /// <returns>The parsed string.</returns> public override string Parse(XmlParser parser, StreamHandler Reader, IXmlPacketSegmentContainer Container) { string content = "List of " + this.SegmentName + ":" + Environment.NewLine; ulong i = 0; while (Reader.BaseStream.Position < Reader.BaseStream.Length) content += ParseList(i++, parser, Reader, this); return content; }
/// <summary> /// Construct ButtonPanelConfiguration instance from xml element. /// </summary> /// <param name="panelElement"></param> /// <param name="xmlParser"></param> public ButtonPanelConfiguration(XmlElement panelElement, XmlParser xmlParser) : base(panelElement, xmlParser) { this.ButtonAlignment = xmlParser.ParseEnum<HorizontalAlign>(panelElement, "@ButtonAlignment"); this.Buttons = new Collection<ButtonConfiguration>(); XmlNodeList buttonNodeList = panelElement.SelectNodes("p:Button", xmlParser.NamespaceManager); foreach (XmlElement buttonElement in buttonNodeList.Cast<XmlElement>()) this.Buttons.Add(new ButtonConfiguration(buttonElement, xmlParser)); }
/// <summary> /// Construct QueryPanelConfiguration instance from xml element. /// </summary> /// <param name="queryPanelElement"></param> /// <param name="xmlParser"></param> public QueryPanelConfiguration(XmlElement queryPanelElement, XmlParser xmlParser) : base(queryPanelElement, xmlParser) { this.Controls = new Collection<QueryFieldConfiguration>(); foreach (XmlNode controlNode in queryPanelElement.ChildNodes) { XmlElement controlElement = controlNode as XmlElement; if (controlElement != null) this.Controls.Add(new QueryFieldConfiguration(controlElement, xmlParser)); } }
static string GetName (XmlParser parser) { var namedObject = parser.Nodes.First () as INamedXObject; Assert.NotNull (namedObject); if (namedObject.IsNamed) return namedObject.Name.ToString (); var state = parser.CurrentState as XmlNameState; Assert.NotNull (state); return ((IXmlParserContext)parser).KeywordBuilder.ToString (); }
public void ParseXml(XmlParser xmlparser, string nodename) { string rootnode = xmlparser.GetRootNode(); rootnode = rootnode + "->" + nodename + "->"; Font = LoadFont(xmlparser.GetString(rootnode + "Font")); Text = xmlparser.GetString(rootnode + "Text"); Color = xmlparser.GetColor(rootnode + "Color"); Alpha = xmlparser.GetFloat(rootnode + "Alpha"); Scale = xmlparser.GetFloat(rootnode + "Scale"); Layer = xmlparser.GetFloat(rootnode + "Layer"); }
public void xmlParse( string infile, List<string> ExpectedOut ) { Contract.Requires(infile != null); var x = new XmlParser(); var dictionary = new Dictionary<string, string>(); x.Add( new String[] { "test-file", "users", "user", "name" }, dictionary, (dict, str) => { dict["name"] = str; return null; }, (dict, str) => { return null; }, (dict, str) => { return null; } ); x.Add( new String[] { "test-file", "users", "user", "$name" }, dictionary, (dict, str) => { dict["name"] = str; return null; }, (dict, str) => { return null; }, (dict, str) => { return null; } ); x.Add( new String[] { "test-file", "users", "user", "phone" }, dictionary, (dict, str) => { dict["phone"] = str; return null; }, (dict, str) => { return null; }, (dict, str) => { return null; } ); x.Add( new String[] { "test-file", "users", "user" }, dictionary, (dict, str) => { return null; }, (dict, str) => { dict.Clear(); return null; }, (dict, str) => { return (dict.ContainsKey("name") ? "name= " + dict["name"] : "") + (dict.ContainsKey("phone") ? ", phone= " + dict["phone"] : ""); }); x.Process(infile); if (ExpectedOut != null) { Assert.That(x.Error, Is.EqualTo(XmlParser<string>.Errors.None)); Assert.That(x.Output, Is.EqualTo(ExpectedOut)); } else { Assert.That(x.Error, Is.EqualTo(XmlParser<string>.Errors.InvalidXml)); } }
void createQuiz(WWW l) { XmlDocument quiz = new XmlDocument(); quiz.LoadXml(l.text); //----------------QUIZ-----------------// parseXML = new XmlParser (quiz); quizGraph = parseXML.GetGraph(); //Start at question 1 currentNode = quizGraph.GetNodeList()[0]; quizGraph.DisplayGraph(); quizTime = true; }
public static void Start(string configFile) { portals = new Dictionary<byte,Dictionary<byte, PortalInfo>>(); try { xml = new XmlParser(configFile); } catch (Exception) { Logger.ShowError(" cannot read the portal database file.",null); return; } XmlNodeList XMLitems = xml.Parse("portal"); Logger.ShowInfo("Portal database contains " + XMLitems.Count + " portals.",null); for (int i = 0; i < XMLitems.Count; i++) AddPortal(XMLitems.Item(i)); xml = null; }
public void StateShouldBeRazorRootStateAfterCodeBlock () { editor.Text = @"@{ } "; var parser = new XmlParser (new RazorRootState (), false); var tracker = new DocumentStateTracker<XmlParser> (parser, editor); editor.CaretLine = 3; tracker.UpdateEngine (); Assert.IsInstanceOf<RazorRootState> (tracker.Engine.CurrentState); }
public static void Start(string configFile) { mobs = new Dictionary<uint, Mob>(); try { xml = new XmlParser(configFile); } catch (Exception) { Logger.ShowError(" cannot read the Mob database file.", null); return; } XmlNodeList XMLitems = xml.Parse("Mob"); Logger.ShowInfo("Mob database contains " + XMLitems.Count + " Mobs.", null); for (int i = 0; i < XMLitems.Count; i++) AddMob(XMLitems.Item(i)); xml = null; }
/// <summary> /// Overrides <see cref="XmlPacketSegment.Parse"/>, /// parsing the current StaticListPacketSegment. /// </summary> /// <param name="Reader">The packet data reader.</param> /// <param name="Container">The parent packet segment container.</param> /// <param name="parser">The Xml packet parser.</param> /// <returns>The parsed string.</returns> public override string Parse(XmlParser parser, StreamHandler Reader, IXmlPacketSegmentContainer Container) { string content = "Static List (" + this.SegmentName + ": " + this.Length + ")" + Environment.NewLine; // This looks like this: // List (Static Count: 2) -- Header. // 0) Member1: 1 -- These two lines are parsed // Member2: 2 -- by the ParseList overrides. // 1) Member1: 3 // Member2: 4 for (ulong i = 0; i < this.Length; ++i) content += ParseList(i, parser, Reader, this); return content; }
/// <summary> /// Construct CustomConfiguration instance from xml element. /// </summary> /// <param name="baseControlConfigurationElement"></param> /// <param name="xmlParser"></param> public CustomConfiguration(XmlElement baseControlConfigurationElement, XmlParser xmlParser) : base(baseControlConfigurationElement, xmlParser) { string typeName = xmlParser.ParseString(baseControlConfigurationElement, "@Type"); try { this.Type = Kit.GetType(typeName); } catch (NotImplementedException exp) { throw new ConfigurationErrorsException(exp.Message, exp); } this.ResolverName = xmlParser.ParseString(baseControlConfigurationElement, "@ResolverName"); IControlValueResolverFactory controlValueResolverFactory = SpringContext.Current.GetObject<IControlValueResolverFactory>(); if(!controlValueResolverFactory.Contains(this.ResolverName)) throw new ConfigurationErrorsException(string.Format(CultureInfo.InvariantCulture, Resources.DP_ControlValueResolverUnavailable, this.ResolverName)); }
/// <summary> /// Construct DetailPanelConfiguration instance from xml element. /// </summary> /// <param name="panelElement"></param> /// <param name="xmlParser"></param> public DetailPanelConfiguration(XmlElement panelElement, XmlParser xmlParser) : base(panelElement, xmlParser) { this.typeName = xmlParser.ParseString(panelElement, "p:Type"); ValidateTypeName(this.typeName); this.SkinPath = xmlParser.ParseString(panelElement, "p:SkinPath"); this.Width = xmlParser.ParseInt(panelElement, "@Width", 960); this.Height = xmlParser.ParseInt(panelElement, "@Height", 600); this.Resizable = xmlParser.ParseBoolean(panelElement, "@Resizable", false); this.Draggable = xmlParser.ParseBoolean(panelElement, "@Draggable", false); this.ShowMessageAfterSavedSuccessfully = xmlParser.ParseBoolean(panelElement, "@ShowMessageAfterSavedSuccessfully", true); this.SetFocusOnFirstInputControlAutomatically = xmlParser.ParseBoolean(panelElement, "@SetFocusOnFirstInputControlAutomatically", true); short defaultFormButtons = 0; XmlElement saveAndAddAnotherButtonElement = panelElement.SelectSingleNode("p:SaveAndAddAnotherButton", xmlParser.NamespaceManager) as XmlElement; if (saveAndAddAnotherButtonElement != null) { this.SaveAndAddAnotherButton = new FormPanelButtonConfiguration(saveAndAddAnotherButtonElement, xmlParser); this.SaveAndAddAnotherButton.Text = this.SaveAndAddAnotherButton.Text ?? Resources.DPCtrl_SaveAndAddAnotherText; if (this.SaveAndAddAnotherButton.IsFormDefaultButton) defaultFormButtons++; } XmlElement saveAndCloseButtonElement = panelElement.SelectSingleNode("p:SaveAndCloseButton", xmlParser.NamespaceManager) as XmlElement; if (saveAndCloseButtonElement != null) { this.SaveAndCloseButton = new FormPanelButtonConfiguration(saveAndCloseButtonElement, xmlParser); this.SaveAndCloseButton.Text = this.SaveAndCloseButton.Text ?? Resources.DPCtrl_SaveAndCloseText; if (this.SaveAndCloseButton.IsFormDefaultButton) defaultFormButtons++; } XmlElement cancelButtonElement = panelElement.SelectSingleNode("p:CancelButton", xmlParser.NamespaceManager) as XmlElement; if (cancelButtonElement != null) { this.CancelButton = new FormPanelButtonConfiguration(cancelButtonElement, xmlParser); this.CancelButton.Text = this.CancelButton.Text ?? Resources.DPCtrl_CancelText; if (this.CancelButton.IsFormDefaultButton) defaultFormButtons++; } if (defaultFormButtons > 1) throw new ConfigurationErrorsException(@"The buttons with attribute ""IsFormDefaultButton"" equals to true should be one at maximum."); }
/// <summary> /// Parses one list element. /// </summary> /// <param name="Reader">The packet data reader.</param> /// <param name="List">Current list.</param> /// <param name="index">Index of the current element.</param> /// <param name="parser">The Xml packet parser.</param> /// <returns>The parsed string.</returns> public string ParseList(ulong index, XmlParser parser, StreamHandler Reader, ListPacketSegment List) { // 1) Member1: 3 // Member2: 4 string content = index.ToString().PadLeft(3) + ") "; bool first = true; foreach (XmlPacketSegment segment in List.GetContainedSegments()) { if (!first) content += string.Empty.PadRight(5); else first = false; content += segment.Parse(parser, Reader, List).PadMultiline(5) + Environment.NewLine; } return content; }
public override ParsedDocument Parse (bool storeAst, string fileName, TextReader content, MonoDevelop.Projects.Project project = null) { var doc = new XmlParsedDocument (fileName); doc.Flags |= ParsedDocumentFlags.NonSerializable; try { var xmlParser = new XmlParser (new XmlRootState (), true); xmlParser.Parse (content); doc.XDocument = xmlParser.Nodes.GetRoot (); doc.Add (xmlParser.Errors); if (doc.XDocument != null && doc.XDocument.RootElement != null) { if (!doc.XDocument.RootElement.IsEnded) doc.XDocument.RootElement.End (xmlParser.Location); } } catch (Exception ex) { MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing xml document", ex); } return doc; }
public override System.Threading.Tasks.Task<ParsedDocument> Parse (ParseOptions parseOptions, System.Threading.CancellationToken cancellationToken) { var doc = new MonoDevelop.Xml.Editor.XmlParsedDocument (parseOptions.FileName); doc.Flags = ParsedDocumentFlags.NonSerializable; try { var xmlParser = new XmlParser ( new XmlRootState (new HtmlTagState (), new HtmlClosingTagState (true)), true); xmlParser.Parse (parseOptions.Content.CreateReader ()); doc.XDocument = xmlParser.Nodes.GetRoot (); doc.AddRange (xmlParser.Errors); if (doc.XDocument != null) doc.AddRange (Validate (doc.XDocument)); } catch (Exception ex) { MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing HTML document", ex); } return System.Threading.Tasks.Task.FromResult((ParsedDocument)doc); }
public override void Initialize () { base.Initialize (); UpdateOwnerProjects (); var parser = new XmlParser (CreateRootState (), false); tracker = new DocumentStateTracker<XmlParser> (parser, Editor); Document.DocumentParsed += UpdateParsedDocument; if (Document.ParsedDocument != null) { lastCU = Document.ParsedDocument; OnParsedDocumentUpdated (); } if (IdeApp.Workspace != null) { IdeApp.Workspace.FileAddedToProject += HandleProjectChanged; IdeApp.Workspace.FileRemovedFromProject += HandleProjectChanged; } }
public override System.Threading.Tasks.Task<ParsedDocument> Parse (ParseOptions parseOptions, System.Threading.CancellationToken cancellationToken) { var doc = new XmlParsedDocument (parseOptions.FileName); doc.Flags |= ParsedDocumentFlags.NonSerializable; try { var xmlParser = new XmlParser (new XmlRootState (), true); xmlParser.Parse (parseOptions.Content.CreateReader ()); doc.XDocument = xmlParser.Nodes.GetRoot (); // TODO error conversion! //doc.Add (xmlParser.Errors); if (doc.XDocument != null && doc.XDocument.RootElement != null) { if (!doc.XDocument.RootElement.IsEnded) doc.XDocument.RootElement.End (xmlParser.Location); } } catch (Exception ex) { MonoDevelop.Core.LoggingService.LogError ("Unhandled error parsing xml document", ex); } return System.Threading.Tasks.Task.FromResult((ParsedDocument)doc); }
/// <summary> /// Construct QueryFieldConfiguration instance from xml element. /// </summary> /// <param name="queryFieldControlElement"></param> /// <param name="xmlParser"></param> public QueryFieldConfiguration(XmlElement queryFieldControlElement, XmlParser xmlParser) { this.FieldName = xmlParser.ParseString(queryFieldControlElement, "@FieldName"); this.Operator = xmlParser.ParseEnum<QueryFieldOperators>(queryFieldControlElement, "@Operator"); this.Occupation = xmlParser.ParseInt(queryFieldControlElement, "@Occupation", -1); string fieldValueTypeName = xmlParser.ParseString(queryFieldControlElement, "@FieldValueType"); if (!Kit.IsEmpty(fieldValueTypeName)) { try { this.FieldValueType = Kit.GetType(fieldValueTypeName); } catch (NotImplementedException exp) { throw new ConfigurationErrorsException(exp.Message, exp); } } this.Control = BaseControlConfiguration.Create(queryFieldControlElement, xmlParser); this.Occupation = QueryFieldControlFactory.CalculateQueryControlOccupation(this); }
/// <summary> /// Construct ButtonConfiguration instance from xml element. /// </summary> /// <param name="buttonElement"></param> /// <param name="xmlParser"></param> public ButtonConfiguration(XmlElement buttonElement, XmlParser xmlParser) { this.Css = xmlParser.ParseString(buttonElement, "@Css"); this.Text = xmlParser.ParseString(buttonElement, "@Text"); this.ToolTip = xmlParser.ParseString(buttonElement, "@ToolTip"); this.ImageUrl = xmlParser.ParseString(buttonElement, "@ImageUrl"); this.CommandArgument = xmlParser.ParseString(buttonElement, "@CommandArgument"); if(protectedCommandArguments.Contains(this.CommandArgument.ToUpperInvariant())) throw new ConfigurationErrorsException(@"'Delete', 'Update' and 'View' are prohibited command arguments in button configuration."); this.ButtonRenderType = xmlParser.ParseEnum<ButtonRenderTypes>(buttonElement, "@Type"); this.OnClientClick = xmlParser.ParseString(buttonElement, "p:OnClientClick"); XmlElement gridSelectionRequiredElement = buttonElement.SelectSingleNode("p:GridSelectionRequired", xmlParser.NamespaceManager) as XmlElement; if (gridSelectionRequiredElement != null) { this.GridSelectionRequired = true; this.GridSelectionRequiredWarningMessage = xmlParser.ParseString(gridSelectionRequiredElement, "@WarningMessage"); } }
/// <summary> /// set openWin /// </summary> /// <param name="valueStr"></param> private void setOpenWin(String valueStr) { _openWin = XmlParser.getBoolean(valueStr); }
public void SuccessTest5() { string text = "<a foo=''"; Assert.AreEqual(String.Empty, XmlParser.GetAttributeValueAtIndex(text, text.Length - 1)); }
public void DotCharIsValidAttributeValueChar() { Assert.IsTrue(XmlParser.IsAttributeValueChar('.')); }
public void SuccessTest2() { string text = "<a foo=\"abc\""; Assert.AreEqual("abc", XmlParser.GetAttributeValueAtIndex(text, text.Length - 1)); }
public OpenEditorScreenMessage(string filePath, XmlParser parser) { FilePath = filePath; Parser = parser; }
public void SetValueByPath(string path, object value) { XmlParser.SetValueByPath(this.Configuration, path, value); }
public object GetValueByKey(string key) { return(XmlParser.GetValueByKey(this.xmlHt, key)); }
public void EqualsSignTest() { string xml = "<foo a="; Assert.IsFalse(XmlParser.IsInsideAttributeValue(xml, xml.Length)); }
public void DoubleQuotesTest5() { string xml = "<foo a=\"\""; Assert.IsTrue(XmlParser.IsInsideAttributeValue(xml, 8)); }
public void NoXmlElementStart() { string xml = "foo a=\""; Assert.IsFalse(XmlParser.IsInsideAttributeValue(xml, xml.Length)); }
public void DoubleQuotesTest3() { string xml = "<foo a=\"\""; Assert.IsFalse(XmlParser.IsInsideAttributeValue(xml, xml.Length)); }
public void InvalidString() { Assert.IsFalse(XmlParser.IsInsideAttributeValue(String.Empty, 10)); }
public void LeftCurlyBracketIsValidAttributeValueChar() { Assert.IsTrue(XmlParser.IsAttributeValueChar('{')); }
/// <summary> /// set AllowEvents /// </summary> /// <param name="valueStr"></param> public void SetAllowEvents(String valueStr) { _allowEvents = XmlParser.getBoolean(valueStr); }
/// <summary> /// set isPrg /// </summary> /// <param name="valueStr"></param> private void setIsPrg(String valueStr) { _isPrg = XmlParser.getBoolean(valueStr); }
public void SingleQuoteTest1() { string xml = "<foo a='"; Assert.IsTrue(XmlParser.IsInsideAttributeValue(xml, xml.Length)); }
public object GetValueByPath(string path) { return(XmlParser.GetValueByPath(this.xmlHt, path)); }
public static object XmlToObject(string xml) { return(XmlParser.FromXml(RemoveComment(xml), GetRuleAlias())); }
public static IDocument ToXmlDocument(this String sourceCode, IConfiguration configuration = null) { var xmlParser = new XmlParser(configuration); return(xmlParser.Parse(sourceCode)); }
public void HashCharIsValidAttributeValueChar() { Assert.IsTrue(XmlParser.IsAttributeValueChar('#')); }
void SelectPath(int depth, bool contents) { //clone the parser and put it in tree mode XmlParser treeParser = tracker.Engine.GetTreeParser(); //locate the node var path = new List <XObject> (treeParser.Nodes); //note: list is backwards, and we want ignore the root XDocument XObject ob = path [path.Count - (depth + 2)]; var node = ob as XNode; var el = node as XElement; //hoist this as it may not be cheap to evaluate (P/Invoke), but won't be changing during the loop int textLen = Editor.Length; //run the parser until the tag's closed, or we move to its sibling or parent if (node != null) { while (node.NextSibling == null && treeParser.Position < textLen && treeParser.Nodes.Peek() != ob.Parent) { char c = Editor.GetCharAt(treeParser.Position); treeParser.Push(c); if (el != null && el.IsClosed && el.ClosingTag.IsComplete) { break; } } } else { while (ob.Region.End < ob.Region.Begin && treeParser.Position < textLen && treeParser.Nodes.Peek() != ob.Parent) { char c = Editor.GetCharAt(treeParser.Position); treeParser.Push(c); } } if (el == null) { LoggingService.LogDebug("Selecting {0}", ob.Region); EditorSelect(ob.Region); } else if (el.IsClosed) { LoggingService.LogDebug("Selecting {0}-{1}", el.Region.Begin, el.ClosingTag.Region.End); contents &= !el.IsSelfClosing; //pick out the locations, with some offsets to account for the parsing model var s = contents? el.Region.End : el.Region.Begin; var e = contents? el.ClosingTag.Region.Begin : el.ClosingTag.Region.End; EditorSelect(new DocumentRegion(s, e)); } else { LoggingService.LogDebug("No end tag found for selection"); } }
public void SuccessTest7() { string text = "<a foo='a\"b\"c'"; Assert.AreEqual("a\"b\"c", XmlParser.GetAttributeValueAtIndex(text, text.Length - 1)); }
public void RightAngleBracketIsNotValidAttributeValueChar() { Assert.IsFalse(XmlParser.IsAttributeValueChar('>')); }
/// <summary> /// get the task attributes /// </summary> protected virtual bool setAttribute(string attribute, string valueStr) { bool isTagProcessed = true; switch (attribute) { case XMLConstants.MG_ATTR_APPL_GUID: ApplicationGuid = valueStr; break; case XMLConstants.MG_ATTR_PROGRAM_ISN: ProgramIsn = Int32.Parse(valueStr); break; case XMLConstants.MG_ATTR_TASK_ISN: TaskIsn = Int32.Parse(valueStr); break; case XMLConstants.MG_ATTR_TOOLKIT_PARENT_TASK: if (Int32.Parse(valueStr) != 0) { StudioParentTask = (TaskBase)Manager.MGDataTable.GetTaskByID(valueStr); } IsSubtask = true; break; case XMLConstants.MG_ATTR_TASKID: setTaskId(valueStr); if (Events.ShouldLog(Logger.LogLevels.Development)) { Events.WriteDevToLog("TASK: " + _taskTag); } break; case XMLConstants.MG_ATTR_CTL_IDX: setCtlAndCompIdx(valueStr); break; case XMLConstants.MG_ATTR_MAINPRG: setMainPrg(valueStr); break; case XMLConstants.MG_ATTR_NULL_ARITHMETIC: setNullArithmetic(valueStr); break; case XMLConstants.MG_ATTR_INTERACTIVE: setIsInteracive(valueStr); break; case XMLConstants.MG_ATTR_OPEN_WIN: setOpenWin(valueStr); break; case XMLConstants.MG_ATTR_ALLOW_EVENTS: SetAllowEvents(valueStr); break; case XMLConstants.MG_ATTR_ISPRG: setIsPrg(valueStr); break; case XMLConstants.MG_ATTR_ICON_FILE_NAME: IconFileName = valueStr; break; case XMLConstants.MG_ATTR_SYS_CONTEXT_MENU: _systemContextMenu = Int32.Parse(valueStr); break; case XMLConstants.MG_ATTR_PARALLEL: IsParallel = XmlParser.getBoolean(valueStr); break; case XMLConstants.MG_ATTR_SORT_BY_RECENTLY_USED: #if !PocketPC Manager.MenuManager.WindowList.SetSortByRecentlyUsed(XmlParser.getBoolean(valueStr)); #endif break; default: isTagProcessed = false; break; } return(isTagProcessed); }
/// <summary> /// To allocate and fill inner objects of the class /// </summary> /// <param name = "foundTagName">possible tag name , name of object, which need be allocated</param> /// <param name="parentForm">the form of the task that called the current task (note: NOT triggering task)</param> protected virtual bool initInnerObjects(String foundTagName, MgFormBase parentForm) { XmlParser parser = Manager.GetCurrentRuntimeContext().Parser; switch (foundTagName) { case XMLConstants.MG_TAG_HELPTABLE: if (_helpTab == null) { _helpTab = new Helps(); } if (Events.ShouldLog(Logger.LogLevels.Development)) { Events.WriteDevToLog(string.Format("{0} ...", foundTagName)); } _helpTab.fillData(); break; case XMLConstants.MG_TAG_DVHEADER: if (Events.ShouldLog(Logger.LogLevels.Development)) { Events.WriteDevToLog(string.Format("{0} ...", foundTagName)); } DataView.fillHeaderData(); break; case XMLConstants.MG_TAG_PROP: _propTab.fillData(this, 'T'); break; case XMLConstants.MG_TAG_FORM: Form = FormInitData(parentForm); break; case XMLConstants.MG_TAG_ASSEMBLIES: int start = parser.getCurrIndex(); int endContext = parser.getXMLdata().IndexOf('/' + XMLConstants.MG_TAG_ASSEMBLIES, parser.getCurrIndex()); parser.setCurrIndex(endContext); parser.setCurrIndex2EndOfTag(); String assemblyData = parser.getXMLdata().Substring(start, parser.getCurrIndex() - start); //read assemblies data using sax parser try { var mgSAXParser = new MgSAXParser(new AssembliesSaxHandler()); mgSAXParser.Parse(assemblyData); } catch (Exception ex) { Events.WriteExceptionToLog(ex); } break; case XMLConstants.MG_ATTR_MENU_CONTENT: // set current index after tag name end parser.setCurrIndex(parser.getXMLdata().IndexOf(XMLConstants.MG_ATTR_MENU_CONTENT, parser.getCurrIndex()) + XMLConstants.MG_ATTR_MENU_CONTENT.Length + 1); endContext = parser.getXMLdata().IndexOf("</" + XMLConstants.MG_ATTR_MENU_CONTENT, parser.getCurrIndex()); _menusContent = Encoding.Unicode.GetBytes(parser.getXMLsubstring(endContext)); Manager.MenuManager.getApplicationMenus(this); parser.setCurrIndex(endContext); parser.setCurrIndex2EndOfTag(); break; default: return(false); } return(true); }
/// <summary> /// set isInteractive /// </summary> /// <param name="valueStr"></param> private void setIsInteracive(String valueStr) { IsInteractive = XmlParser.getBoolean(valueStr); }
public void MixedQuotesTest3() { string xml = "<foo a=\"''"; Assert.IsTrue(XmlParser.IsInsideAttributeValue(xml, xml.Length)); }
public void SuccessTest4() { string text = "<a foo='abc'"; Assert.AreEqual("abc", XmlParser.GetAttributeValueAtIndex(text, text.IndexOf("abc"))); }
public void FailureTest1() { string text = "<a foo='a"; Assert.AreEqual(String.Empty, XmlParser.GetAttributeValueAtIndex(text, text.Length - 1)); }
public void TeatUp() { parser = new XmlParser(); xmlDoc = new XmlDocument(); xmlDoc.Load(path); }