static public DvCodedText ParseString(string codedTextString) { DesignByContract.Check.Require(!string.IsNullOrEmpty(codedTextString), "codedTextString must not be null or empty"); Match match = Regex.Match(codedTextString, stringRegExValue, RegexOptions.Compiled | RegexOptions.Singleline); if (!match.Success) { throw new ApplicationException("Invalid DV_CODED_TEXT string"); } System.Text.RegularExpressions.Group value = match.Groups["value"]; System.Text.RegularExpressions.Group codeString = match.Groups["code_string"]; System.Text.RegularExpressions.Group terminologyId = match.Groups["terminology_id"]; if (value == null) { throw new ApplicationException("value must not be null"); } if (codeString == null) { throw new ApplicationException("codeString must not be null"); } if (terminologyId == null) { throw new ApplicationException("terminologyId must not be null"); } return(new DvCodedText(value.Value, codeString.Value, terminologyId.Value)); }
void ReplaceUrlWithAbsoluteUrl(StringBuilder builder, Group matchedUrlGroup, string currentDirectory) { var relativeUrl = matchedUrlGroup.Value.Trim('"', '\''); var absoluteUrl = CreateAbsoluteUrl(relativeUrl, currentDirectory); builder.Remove(matchedUrlGroup.Index, matchedUrlGroup.Length); builder.Insert(matchedUrlGroup.Index, absoluteUrl); }
private double[] regXb(String line) { CultureInfo culture = new CultureInfo("en-US"); double[] xb = new double[6]; Regex regExXb = new Regex(@"XB\s*=\s*(\-*\d*\.{0,1}\d*)\s*,\s*(\-*\d*\.{0,1}\d*)\s*,\s*(\-*\d*\.{0,1}\d*)\s*,\s*(\-*\d*\.{0,1}\d*)\s*,\s*(\-*\d*\.{0,1}\d*)\s*,\s*(\-*\d*\.{0,1}\d*)", RegexOptions.IgnoreCase); Match xbMatch = regExXb.Match(line); if (xbMatch.Success) { System.Text.RegularExpressions.Group x1G = xbMatch.Groups[1]; System.Text.RegularExpressions.Group x2G = xbMatch.Groups[2]; System.Text.RegularExpressions.Group y1G = xbMatch.Groups[3]; System.Text.RegularExpressions.Group y2G = xbMatch.Groups[4]; System.Text.RegularExpressions.Group z1G = xbMatch.Groups[5]; System.Text.RegularExpressions.Group z2G = xbMatch.Groups[6]; xb[0] = Convert.ToDouble(x1G.Value, culture); xb[1] = Convert.ToDouble(x2G.Value, culture); xb[2] = Convert.ToDouble(y1G.Value, culture); xb[3] = Convert.ToDouble(y2G.Value, culture); xb[4] = Convert.ToDouble(z1G.Value, culture); xb[5] = Convert.ToDouble(z2G.Value, culture); } else { xb = null; } return(xb); }
////////////////////// Group /////////////////////////////////////// // constructors // fields // properties static void Group_Captures(JSVCall vc) { System.Text.RegularExpressions.Group _this = (System.Text.RegularExpressions.Group)vc.csObj; var result = _this.Captures; JSMgr.datax.setObject((int)JSApi.SetType.Rval, result); }
void ApplyUrlToBlock(Gtk.TextIter start, Gtk.TextIter end) { NoteBuffer.GetBlockExtents(ref start, ref end, 256 /* max url length */, Note.TagTable.UrlTag); Buffer.RemoveTag(Note.TagTable.UrlTag, start, end); Gtk.TextIter searchiter = start; for (Match match = regex.Match(start.GetSlice(end)); match.Success; match = match.NextMatch()) { System.Text.RegularExpressions.Group group = match.Groups [1]; /* * Logger.Log ("Highlighting url: '{0}' at offset {1}", * group, * group.Index); */ // Use the ForwardSearch instead of group's Index to account for multibyte chars in the text. // We'll search using the exact match value within provided boundaries. Gtk.TextIter startiter, enditer; searchiter.ForwardSearch(group.Value, Gtk.TextSearchFlags.VisibleOnly, out startiter, out enditer, end); searchiter = enditer; Buffer.ApplyTag(Note.TagTable.UrlTag, startiter, enditer); } }
public static Group Synchronized(Group inner) { Contract.Requires(inner != null); Contract.Ensures(Contract.Result<Group>() != null); return default(Group); }
public static Group Synchronized(Group inner) { Contract.Ensures(Contract.Result<System.Text.RegularExpressions.Group>() != null); Contract.Ensures(Contract.Result<System.Text.RegularExpressions.Group>() == inner); return default(Group); }
private string GetPathThroughLastSlash(SourceText text, int position, Group quotedPathGroup) { return PathCompletionUtilities.GetPathThroughLastSlash( quotedPath: quotedPathGroup.Value, quotedPathStart: GetQuotedPathStart(text, position, quotedPathGroup), position: position); }
private TextSpan GetTextChangeSpan(SourceText text, int position, Group quotedPathGroup) { return PathCompletionUtilities.GetTextChangeSpan( quotedPath: quotedPathGroup.Value, quotedPathStart: GetQuotedPathStart(text, position, quotedPathGroup), position: position); }
public static string FormatWith(this string format, IFormatProvider provider, object source) { if (format == null) { throw new ArgumentNullException("format"); } Regex r = new Regex(@"(?<start>\{)+(?<property>[\w\.\[\]]+)(?<format>:[^}]+)?(?<end>\})+", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase); List <object> values = new List <object>(); string rewrittenFormat = r.Replace(format, delegate(Match m) { System.Text.RegularExpressions.Group startGroup = m.Groups["start"]; System.Text.RegularExpressions.Group propertyGroup = m.Groups["property"]; System.Text.RegularExpressions.Group formatGroup = m.Groups["format"]; System.Text.RegularExpressions.Group endGroup = m.Groups["end"]; values.Add((propertyGroup.Value == "0") ? source : System.Web.UI.DataBinder.Eval(source, propertyGroup.Value)); return(new string('{', startGroup.Captures.Count) + (values.Count - 1) + formatGroup.Value + new string('}', endGroup.Captures.Count)); }); return(string.Format(provider, rewrittenFormat, values.ToArray())); }
private IEnumerable<Frame> CreateFrames( Group framesGroup) { return from Capture capture in framesGroup.Captures select CreateFrame(capture.Value); }
void ApplyWikiwordToBlock(Gtk.TextIter start, Gtk.TextIter end) { NoteBuffer.GetBlockExtents(ref start, ref end, 80 /* max wiki name */, broken_link_tag); Buffer.RemoveTag(broken_link_tag, start, end); for (Match match = regex.Match(start.GetText(end)); match.Success; match = match.NextMatch()) { System.Text.RegularExpressions.Group group = match.Groups [1]; Logger.Debug("Highlighting wikiword: '{0}' at offset {1}", group, group.Index); Gtk.TextIter start_cpy = start; start_cpy.ForwardChars(group.Index); end = start_cpy; end.ForwardChars(group.Length); if (Manager.Find(group.ToString()) == null) { Buffer.ApplyTag(broken_link_tag, start_cpy, end); } } }
static void Group_Success(JSVCall vc) { System.Text.RegularExpressions.Group _this = (System.Text.RegularExpressions.Group)vc.csObj; var result = _this.Success; JSApi.setBooleanS((int)JSApi.SetType.Rval, (System.Boolean)(result)); }
void ApplyUrlToBlock(Gtk.TextIter start, Gtk.TextIter end) { NoteBuffer.GetBlockExtents(ref start, ref end, 256 /* max url length */, Note.TagTable.UrlTag); Buffer.RemoveTag(Note.TagTable.UrlTag, start, end); for (Match match = regex.Match(start.GetSlice(end)); match.Success; match = match.NextMatch()) { System.Text.RegularExpressions.Group group = match.Groups [1]; /* * Logger.Log ("Highlighting url: '{0}' at offset {1}", * group, * group.Index); */ Gtk.TextIter start_cpy = start; start_cpy.ForwardChars(group.Index); end = start_cpy; end.ForwardChars(group.Length); Buffer.ApplyTag(Note.TagTable.UrlTag, start_cpy, end); } }
/// <summary> /// Concatenates the captures of <paramref name="group" /> to a string. /// </summary> /// <param name="group"><see cref="Group" /> containing the captures.</param> /// <returns> /// <see cref="string" /> containg the concatenated captures. /// </returns> /// <remarks> /// A named-group can captured multiple times, when the regular /// expression has a quantifier, e.g. (// (?'Text'.*) )* will match /// multiline comments with group <i>Text</i> having a capture for /// every line. /// </remarks> private string ConcatenateCaptures(Group group) { StringBuilder sb = new StringBuilder(); foreach (Capture capture in group.Captures) { sb.Append(capture.Value); } return sb.ToString(); }
private void AddSubNode(int parentNodeIndex, string caption, Group captureGroup, int groupIndex) { TreeNode newNode = makeCaptureNode(caption); Nodes[parentNodeIndex].Nodes.Add(newNode); Nodes[parentNodeIndex].Nodes[groupIndex - 1].Tag = captureGroup; Nodes[parentNodeIndex].Expand(); }
public static string UpdateSpecLayer(ObjectId objectId, string webLayer) { // TODO: trzeba zalozyc filtr po webLayer i zmieniac wszystkie warstwy w petli poniwaz moze byc kilka tych samych warstw na roznych pietrach Editor ed = acApp.DocumentManager.MdiActiveDocument.Editor; Document acDoc = Application.DocumentManager.MdiActiveDocument; Database acCurDb = acDoc.Database; // Start a transaction using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction()) { // This example returns the layer table for the current database LayerTable acLyrTbl; acLyrTbl = acTrans.GetObject(acCurDb.LayerTableId, OpenMode.ForRead) as LayerTable; string layerName = ""; string oldLayerName = ""; // Pobierz starą nazwę warstwy LayerTableRecord acLyrTblRecOld; acLyrTblRecOld = acTrans.GetObject(objectId, OpenMode.ForRead) as LayerTableRecord; Regex regEx = new Regex(@"\[(.+)\]", RegexOptions.IgnoreCase); Match match = regEx.Match(acLyrTblRecOld.Name); ed.WriteMessage("Match success: " + match.Success.ToString()); if (match.Success) { System.Text.RegularExpressions.Group group = match.Groups[1]; oldLayerName = group.ToString(); } ed.WriteMessage("Old layer: " + oldLayerName); // Step through the Layer table and print each layer name foreach (ObjectId acObjId in acLyrTbl) { LayerTableRecord acLyrTblRec; acLyrTblRec = acTrans.GetObject(acObjId, OpenMode.ForRead) as LayerTableRecord; if (acLyrTblRec.Name.Contains(oldLayerName)) { regEx = new Regex(@"\((.)\)", RegexOptions.IgnoreCase); match = regEx.Match(acLyrTblRec.Name); if (match.Success) { System.Text.RegularExpressions.Group group = match.Groups[1]; Int32.TryParse(group.ToString(), out currentFloor); layerName = "!FDS_SPEC[" + webLayer + "](" + currentFloor + ")"; } acLyrTblRec.UpgradeOpen(); acLyrTblRec.Name = layerName; Random r = new Random(); acLyrTblRec.Color = Color.FromColorIndex(ColorMethod.ByAci, (Int16)(r.Next(225))); ed.WriteMessage("\n" + acLyrTblRec.Name); } } acTrans.Commit(); return(""); } }
private static IReadOnlyList<UriParameter> ParseParameterGroup(Group group) { if (!group.Success) return new UriParameter[] { }; var parameters = group.Value; var splitByAmpersand = parameters.Split('&'); return splitByAmpersand.Select(ParseParameterPart).ToArray(); }
// returns a length, not a position private static int LineBreak(string text, int where, int max) { Regex regex = new Regex(RegexPattern); Match match = null; int end = text.Substring(where).IndexOf('\n'); if (end < 0) { end = text.Substring(where).Length; } int i = 0; // stores current position (relative) int i_sub = 0; // stores the total size of the tags int pos = 0; // stores current position (absolute) bool valid_found = false; int valid = 1; //stores the last valid cutting point string with = ""; // the text with the tags string without = ""; // the text without the tags string temp = ""; // temporary string for holding values System.Text.RegularExpressions.Group tag = null; // a temporary value to store matches from the regex for (i = 0; i <= end;) { if (where + i >= text.Length - 1 || without.Length > max) { break; } pos = where + i; temp = text.Substring(pos); match = regex.Match(temp); if (match.Success) { tag = match.Groups["tag"]; if (tag != null && temp.StartsWith(tag.Value)) { temp = tag.Value; i_sub += temp.Length; i += temp.Length; with += temp; valid = i; valid_found = true; continue; } } char chr = text[pos]; if (char.IsWhiteSpace(chr)) { valid = i + 1; valid_found = true; } with += chr; without += chr; i++; } return(without.Length < max ? with.Length + 1 : valid_found?valid : max + i_sub); }
private static void DisplayCaptures(Group group, TreeNode groupRoot) { foreach (Capture capture in group.Captures) { TreeNode captureRoot = new TreeNode(capture.Value); groupRoot.Nodes.Add(captureRoot); } }
public static double ParseDouble(Group @group) { if (@group.Captures.Count != 1) { throw new ArgumentException("Expected single capture"); } return ParseDouble(@group.Value); }
string GetImageFilename(Group matchedUrlGroup, string currentDirectory) { var originalUrl = matchedUrlGroup.Value.Trim('"', '\''); if (originalUrl.StartsWith("/")) { return PathUtilities.NormalizePath("~" + originalUrl); } return PathUtilities.NormalizePath(PathUtilities.CombineWithForwardSlashes(currentDirectory, originalUrl)); }
private static int GroupToInt(Group g) { int value; if (int.TryParse(g.ToString(), out value)) { return value; } return -1; }
public EditUserForm() { InitializeComponent(); _userName = string.Empty; _password = string.Empty; GroupId = -1; Groups = new Group[0]; }
private static string GetDistinctCount(string @select, Group g, string @from) { var columns = g.ToString().Trim(); if(columns == "DISTINCT") { throw new ArgumentException("Malformed SQL; DISTINCT queries must specify at least one column"); } var distinct = string.Concat(@select, "COUNT(", columns, ") ", @from); return distinct; }
private IEnumerable<Ball> CreateBonusBalls( Group bonusBallsGroup) { return from Capture capture in bonusBallsGroup.Captures let value = capture.Value[0] select value == 'X' ? Ball.CreateStrike() : CreateBall(capture.Value[0]); }
private static uint?getuintFomGroup(System.Text.RegularExpressions.Group grp) { int value; if (grp.Success && int.TryParse(grp.Value, out value)) { return((uint)value); } return(null); }
void OnMenuItemActivated(object sender, EventArgs args) { NoteTag broken_link_tag = Note.TagTable.BrokenLinkTag; Gtk.TextIter note_start, note_end; // We get the whole note as a range // and then just remove the "broken link" tag from it Note.Buffer.GetBounds(out note_start, out note_end); // Sweep 'em & recreate WikiWord broken links (depending on Preferences), Buffer.RemoveTag(broken_link_tag, note_start, note_end); // HACK: The below is copied from Watchers.cs->ApplyWikiwordToBlock() // It turns WikiWords back into broken links after sweeping all broken links, // but only in case WikiWords are enabled. // Most probably there's more elegant way of doing this. if ((bool)Preferences.Get(Preferences.ENABLE_WIKIWORDS)) { const string WIKIWORD_REGEX = @"\b((\p{Lu}+[\p{Ll}0-9]+){2}([\p{Lu}\p{Ll}0-9])*)\b"; Regex regex = new Regex(WIKIWORD_REGEX, RegexOptions.Compiled); NoteBuffer.GetBlockExtents(ref note_start, ref note_end, 80 /* max wiki name */, broken_link_tag); //Buffer.RemoveTag (broken_link_tag, start, end); for (Match match = regex.Match(note_start.GetText(note_end)); match.Success; match = match.NextMatch()) { System.Text.RegularExpressions.Group group = match.Groups [1]; Logger.Debug("Highlighting back wikiword: '{0}' at offset {1}", group, group.Index); Gtk.TextIter start_cpy = note_start; start_cpy.ForwardChars(group.Index); note_end = start_cpy; note_end.ForwardChars(group.Length); if (Manager.Find(group.ToString()) == null) { Buffer.ApplyTag(broken_link_tag, start_cpy, note_end); } } } /// End of hack }
void ExpandUrl(StringBuilder builder, Group matchedUrlGroup, string relativeFilename) { relativeFilename = RemoveFragment(relativeFilename); var file = application.RootDirectory.GetFile(relativeFilename.Substring(2)); if (!file.Exists) return; var hash = HashFileContents(file); var absoluteUrl = application.UrlGenerator.CreateRawFileUrl(relativeFilename, hash); builder.Remove(matchedUrlGroup.Index, matchedUrlGroup.Length); builder.Insert(matchedUrlGroup.Index, absoluteUrl); }
public RegexGroup(Group group, string name) { foreach (Capture c in group.Captures) { _Captures.Add(new RegexCapture(c)); } this._Name = name; this._Value = group.Value; this._Index = group.Index; this._Length = group.Length; }
void ExpandUrl(StringBuilder builder, Group matchedUrlGroup, string relativeFilename) { relativeFilename = RemoveFragment(relativeFilename); var file = sourceDirectory.GetFile(relativeFilename.TrimStart('~', '/')); if (!file.Exists) return; var hash = HashFileContents(file); var absoluteUrl = urlGenerator.CreateRawFileUrl(relativeFilename, hash); builder.Remove(matchedUrlGroup.Index, matchedUrlGroup.Length); builder.Insert(matchedUrlGroup.Index, absoluteUrl); }
/// <summary> /// Helper to retrieve URL parameters from the REST server match data. /// /// Returns a value from the matches or null if not found. Unescapes the URL /// data. Throws RESTArgumentException if the parameter is not found or invalid. /// </summary> public static string GetValue(this Match match, string name) { System.Text.RegularExpressions.Group group = match.Groups[name]; if (!group.Success) { throw new RESTArgumentException("URL parameter not found", name); } // Currently, the url is raw, so we manually decode the partz. return(Uri.UnescapeDataString(group.Value)); }
static public int get_Captures(IntPtr l) { try { System.Text.RegularExpressions.Group self = (System.Text.RegularExpressions.Group)checkSelf(l); pushValue(l, true); pushValue(l, self.Captures); return(2); } catch (Exception e) { return(error(l, e)); } }
public void Deny_Unrestricted () { Assert.AreEqual (1, coll.Count, "Count"); Assert.IsTrue (coll.IsReadOnly, "IsReadOnly"); Assert.IsFalse (coll.IsSynchronized, "IsSynchronized"); Assert.IsNotNull (coll.SyncRoot, "SyncRoot"); Assert.IsNotNull (coll[0], "this[int]"); Assert.IsNotNull (coll.GetEnumerator (), "GetEnumerator"); Group[] groups = new Group[1]; coll.CopyTo (groups, 0); }
// methods static bool Group_Synchronized__Group(JSVCall vc, int argc) { int len = argc; if (len == 1) { System.Text.RegularExpressions.Group arg0 = (System.Text.RegularExpressions.Group)JSMgr.datax.getObject((int)JSApi.GetType.Arg); JSMgr.datax.setObject((int)JSApi.SetType.Rval, System.Text.RegularExpressions.Group.Synchronized(arg0)); } return(true); }
public static MessageSummary Parse(byte[] content) { try { if (content == null || content.Length == 0) { return(null); } MessageSummary ret = null; String body = Encoding.UTF8.GetString(content, 0, content.Length); Match messageMatch = MESSAGE_SUMMARY_EXPR.Match(body); if (messageMatch != null && messageMatch.Success) { String status = messageMatch.Groups["msg_status"].Success ? messageMatch.Groups["msg_status"].Value : String.Empty; String account = messageMatch.Groups["account_uri"].Success ? messageMatch.Groups["account_uri"].Value : String.Empty; if (!String.IsNullOrEmpty(status) && !String.IsNullOrEmpty(account)) { bool waitingMessages = (String.Equals(status, "yes", StringComparison.InvariantCultureIgnoreCase)); ret = new MessageSummary(account, waitingMessages); if (waitingMessages) { System.Text.RegularExpressions.Group lines = messageMatch.Groups["msg_summary_line"]; foreach (Capture capture in lines.Captures) { String line = capture.Value; Match lineMatch = SUMMARY_LINE_EXPR.Match(line); if (lineMatch != null && lineMatch.Success) { String messageClass = lineMatch.Groups["message_context_class"].Value; int newMessages = Convert.ToInt32(lineMatch.Groups["newmsgs"].Success ? lineMatch.Groups["newmsgs"].Value : "0"); int oldMessages = Convert.ToInt32(lineMatch.Groups["oldmsgs"].Success ? lineMatch.Groups["oldmsgs"].Value : "0"); int newUrgentMessages = Convert.ToInt32(lineMatch.Groups["new_urgentmsgs"].Success ? lineMatch.Groups["new_urgentmsgs"].Value : "0"); int oldUrgentMessages = Convert.ToInt32(lineMatch.Groups["old_urgentmsgs"].Success ? lineMatch.Groups["old_urgentmsgs"].Value : "0"); ret.SetMessageCount(messageClass, newMessages, oldMessages, newUrgentMessages, oldUrgentMessages); } } } } } return(ret); } catch (Exception e) { LOG.Error(e); return(null); } }
string GetImageFilename(Group matchedUrlGroup, string currentDirectory, out string queryString, out string fragment) { var originalUrl = matchedUrlGroup.Value.Trim('"', '\''); originalUrl = SplitOnLastOccurence(originalUrl, '#', out fragment); originalUrl = SplitOnLastOccurence(originalUrl, '?', out queryString); if (originalUrl.StartsWith("/")) { return PathUtilities.NormalizePath("~" + originalUrl); } return PathUtilities.NormalizePath(PathUtilities.CombineWithForwardSlashes(currentDirectory, originalUrl)); }
public void Parse(XmlElement configElement) { this.Enabled = configElement.GetAttribute("enabled").EqualsAnyOf("yes", "true", "1"); this.Directory = configElement.GetString("p:directory", XmlNamespaces.Manager); var groups = configElement.SelectNodes("p:groups/p:group", XmlNamespaces.Manager); this.Groups = new Dictionary<string, Group>(); foreach (XmlElement node in groups) { var group = new Group(node); this.Groups.Add(group.Name, group); } }
public MatchItem(Group group) { Children = new ObservableCollection<MatchItem>(); Content = group.Value; if (group.Captures.Count < 2) { return; } foreach (Capture item in group.Captures) { Children.Add(new MatchItem(item)); } }
private static string GetDefaultValue(Group defaultValueGroup) { if (defaultValueGroup.Success) { var defaultValueMatch = defaultValueGroup.Value; // Strip out the equal sign at the beginning Debug.Assert(defaultValueMatch.StartsWith("=", StringComparison.Ordinal)); return defaultValueMatch.Substring(1); } return null; }
public static Group Synchronized(Group inner) { if (inner == null) { throw new ArgumentNullException(); } CaptureCollection captures = inner.Captures; if (inner._capcount > 0) { Capture capture1 = captures[0]; } return inner; }
private static string ProcessIncludes(string str) { MatchCollection matches = g_regInclude.Matches(str); if (matches.Count == 0) { Utilities.LogSubError("Invalid %= in: " + str); } foreach (Match match in matches) { System.Text.RegularExpressions.Group g = match.Groups["num"]; if (g.Success) { foreach (Capture objCapture in g.Captures) //objMatch.Captures { string ID = objCapture.Value; if (!g_Strings.ContainsKey(ID)) { Utilities.LogSubError("Invalid reference: %=" + ID + "% in " + str); if (!IsTranslationMode) { str = str.Replace("%=" + ID + "%", "???"); } // else just leaves the %=xxx% in } else { if (IsTranslationMode) { string sub = g_Strings[ID]; sub = sub.Replace("[", "{"); sub = sub.Replace("]", "}").Replace("&", ""); str = str.Replace("%=" + ID + "%", sub); } else { string insert = g_Strings[ID]; if (insert.EndsWith("...")) { insert = insert.Substring(0, insert.Length - 3); } insert = insert.Replace("&", ""); // remove accelerator keys. When eg a menu name is referenced in explanatory text the & would probably be displayed - explanations, prompts etc. often don't support accelerators str = str.Replace("%=" + ID + "%", insert); } } } } } return(str); }
private static void DetermineScriptingLanguage(AspViewFile file, Group languageName) { switch (languageName.Value.ToLower()) { case "c#": file.Language = ScriptingLanguage.CSharp; break; case "vb": file.Language = ScriptingLanguage.VbNet; break; default: throw new AspViewException("Unsupported view language [{0}] in view [{1}]", languageName, file.ViewName); } }
/// <summary> /// Removes the invalid HTML tags. /// </summary> /// <param name="text">The text.</param> /// <returns></returns> public static string RemoveInvalidHtmlTags(this string text) { return(HtmlTagExpression.Replace(text, new MatchEvaluator((Match m) => { if (!ValidHtmlTags.ContainsKey(m.Groups["tag"].Value)) { return String.Empty; } StringBuilder generatedTag = new StringBuilder(m.Length); System.Text.RegularExpressions.Group tagStart = m.Groups["tag_start"]; System.Text.RegularExpressions.Group tagEnd = m.Groups["tag_end"]; System.Text.RegularExpressions.Group tag = m.Groups["tag"]; System.Text.RegularExpressions.Group tagAttributes = m.Groups["attr"]; generatedTag.Append(tagStart.Success ? tagStart.Value : "<"); generatedTag.Append(tag.Value); foreach (Capture attr in tagAttributes.Captures) { int indexOfEquals = attr.Value.IndexOf('='); // don't proceed any futurer if there is no equal sign or just an equal sign if (indexOfEquals < 1) { continue; } string attrName = attr.Value.Substring(0, indexOfEquals); // check to see if the attribute name is allowed and write attribute if it is if (ValidHtmlTags[tag.Value].Contains(attrName)) { generatedTag.Append(' '); generatedTag.Append(attr.Value); } } // add nofollow to all hyperlinks if (tagStart.Success && tagStart.Value == "<" && tag.Value.Equals("a", StringComparison.OrdinalIgnoreCase)) { generatedTag.Append(" rel=\"nofollow\""); } generatedTag.Append(tagEnd.Success ? tagEnd.Value : ">"); return generatedTag.ToString(); }))); }
public static void AbortBuild(string title, string message, CommandInvokationFailure ex = null) { string str = null; if ((ex != null) && message.StartsWith("Gradle")) { string input = string.Join("\n", ex.StdErr); foreach (GradleError error in gradleErrors) { Match match = error.regex.Match(input); if (match.Success) { System.Text.RegularExpressions.Group[] array = new System.Text.RegularExpressions.Group[match.Groups.Count]; match.Groups.CopyTo(array, 0); title = "Gradle Error: " + error.id; message = string.Format(error.message, (object[])array); str = error.id.ToLower().Replace(' ', '-'); break; } } } if (str != null) { bool flag; Debug.Log($"GRADLE ERROR : {str}"); message = message + "\n(See the Console for details)"; if (Application.platform == RuntimePlatform.WindowsEditor) { flag = EditorUtility.DisplayDialog(title, message, "Troubleshoot", "Ok"); } else { flag = EditorUtility.DisplayDialogComplex(title, message, "Ok", "", "Troubleshoot") == 2; } if (flag) { Help.ShowHelpPage($"file:///unity/Manual/android-gradle-troubleshooting.html#{str}"); } } else { EditorUtility.DisplayDialog(title, message, "Ok"); } if (ex == null) { throw new UnityException(title + "\n" + message); } throw ex; }
public static AdminInfoObject TryParse(string Text) { Regex regex; MatchCollection matches; uint id; string className; AdminInfoProperty[] props; // 1) Check if this is an object response regex = new Regex(@":< OBJECT (?<id>\d*) is CLASS (?<classname>.*)"); matches = regex.Matches(Text); // must have exactly one occurence if it is what we're looking for if (matches.Count != 1) { return(null); } // get values for id and classname System.Text.RegularExpressions.Group gID = matches[0].Groups["id"]; System.Text.RegularExpressions.Group gClassName = matches[0].Groups["classname"]; if (!UInt32.TryParse(gID.ToString(), out id)) { id = 0; } className = gClassName.ToString(); // 2) Parse out properties regex = new Regex(@": (?<propname>\w*)\s*=\s(?<proptype>[\w$]*)\s(?<propvalue>\w*)"); matches = regex.Matches(Text); props = new AdminInfoProperty[matches.Count]; for (int i = 0; i < matches.Count; i++) { props[i] = new AdminInfoProperty( matches[i].Groups["propname"].ToString(), matches[i].Groups["proptype"].ToString(), matches[i].Groups["propvalue"].ToString()); } // 3) Return instance return(new AdminInfoObject(id, className, props)); }
private FilterExpression(string text, int group, int level) { if (string.IsNullOrWhiteSpace(text)) { throw new ArgumentNullException(nameof(text)); } this.Text = text.Trim(); this.Level = level; this.Group = group; MatchCollection matches = FilterExpression.Expression.Value.Matches(this.Text); foreach (Match match in matches) { System.Text.RegularExpressions.Group levelUpGroup = match.Groups[FilterExpression.PatternGroupLevelUp]; if (levelUpGroup.Success && levelUpGroup.Value.Any()) { this.Level += levelUpGroup.Value.Length; this.Group += 1; } System.Text.RegularExpressions.Group operatorGroup = match.Groups[FilterExpression.PatternGroupOperator]; if (operatorGroup.Success) { System.Text.RegularExpressions.Group leftGroup = match.Groups[FilterExpression.PatternGroupLeft]; System.Text.RegularExpressions.Group rightGroup = match.Groups[FilterExpression.PatternGroupRight]; this.Initialize(leftGroup, operatorGroup, rightGroup); } else { string remainder = match.Value.Trim(); if (string.IsNullOrWhiteSpace(remainder)) { continue; } else if (1 == remainder.Length && FilterExpression.BracketClose == remainder[0]) { continue; } else { throw new ArgumentException(remainder, nameof(text)); } } } }
internal AssignedVoice PreAssigned(string avName) { // Need an assignment. string namedef = configVoices[avName].AsString(); if (namedef == null) { return(null); } // Parse the voice assignment options. MatchCollection mc = voicePattern.Matches(namedef); if (mc.Count > 0) { Match m = mc[0]; System.Text.RegularExpressions.Group g1 = m.Groups[1]; string vname = g1.Value; // Default to no rate or pitch shift int vrate = 0; int vpitch = 0; // Look for modifiers. for (int i = 2; i < m.Groups.Count; i++) { System.Text.RegularExpressions.Group g = m.Groups[i]; switch (g.Value) { case "slow": vrate = -1; break; case "fast": vrate = +1; break; case "high": vpitch = +1; break; case "low": vpitch = -1; break; } } // Save all that as one bundle. return(GetNamedVoice(vname, vrate, vpitch)); } return(null); }
private void ParseAttributes() { if (m_attributesAsString != null) { MatchCollection matchCollection = m_AttributeRegEx.Matches(m_attributesAsString.Trim()); if (matchCollection.Count > 0) { m_parsedAttributes = new Dictionary <string, string>(matchCollection.Count, StringEqualityComparer.Instance); for (int i = 0; i < matchCollection.Count; i++) { Match match = matchCollection[i]; string text = null; string html = null; System.Text.RegularExpressions.Group group = match.Groups["name"]; if (group.Length <= 0) { continue; } text = group.Value; group = match.Groups["quotedvalue"]; if (group.Length > 0) { html = group.Value; } else { group = match.Groups["singlequotedvalue"]; if (group.Length > 0) { html = group.Value; } else { group = match.Groups["value"]; if (group.Length > 0) { html = group.Value; } } } m_parsedAttributes[text.ToLowerInvariant()] = HtmlEntityResolver.ResolveEntities(html); } } } m_attributesAsString = null; }
public Summand Parse(string summandString) { // Arggh, I NEVER write a parser on Regexps again var match = Regex.Match(summandString, Pattern); _varsGroup = match.Groups["vars"]; _coefGroup = match.Groups["coef"]; if (_varsGroup.Value == String.Empty && _coefGroup.Value == String.Empty) throw new ParsingException("Некорректный формат слагаемого."); var coef = ParseCoef(); var variables = ParseVariables(); return variables == null ? new Summand(coef) : new Summand(coef, variables); }
static internal Group Synchronized(Group inner) { #endif if (inner == null) throw new ArgumentNullException("inner"); // force Captures to be computed. CaptureCollection capcoll; Capture dummy; capcoll = inner.Captures; if (inner._capcount > 0) dummy = capcoll[0]; return inner; }
public void HighlightWikiWords(Note note) { NoteTag broken_link_tag = note.TagTable.BrokenLinkTag; Gtk.TextIter note_start, note_end; note.Buffer.GetBounds(out note_start, out note_end); // HACK: The below is copied from Watchers.cs->ApplyWikiwordToBlock() // It turns WikiWords back into broken links after sweeping all broken links, // but only in case WikiWords are enabled. // Most probably there's more elegant way of doing this. const string WIKIWORD_REGEX = @"\b((\p{Lu}+[\p{Ll}0-9]+){2}([\p{Lu}\p{Ll}0-9])*)\b"; Regex regex = new Regex(WIKIWORD_REGEX, RegexOptions.Compiled); NoteBuffer.GetBlockExtents(ref note_start, ref note_end, 80 /* max wiki name */, broken_link_tag); for (Match match = regex.Match(note_start.GetText(note_end)); match.Success; match = match.NextMatch()) { System.Text.RegularExpressions.Group group = match.Groups [1]; Logger.Debug("Highlighting back wikiword: '{0}' at offset {1}", group, group.Index); Gtk.TextIter start_cpy = note_start; start_cpy.ForwardChars(group.Index); note_end = start_cpy; note_end.ForwardChars(group.Length); if (note.Manager.Find(group.ToString()) == null) { note.Buffer.ApplyTag(broken_link_tag, start_cpy, note_end); } } /// End of hack }
public Card(string s) : this() { if (s == null) throw new ArgumentNullException("s"); Match match = CardName.Match(s.ToLower()); if (match.Success) { Group[] groups = new Group[match.Groups.Count]; match.Groups.CopyTo(groups, 0); Rank = (CardRank)Enum.Parse(typeof(CardRank), groups[1].Value, true); Suit = (CardSuit)Enum.Parse(typeof(CardSuit), groups[2].Value, true); } else { throw new ArgumentException("The given string does not represent a valid playing card: " + s); } }
private static string replaceMatch( Group match, string text) { if (string.IsNullOrEmpty(text) || !text.Contains(@"$")) { return text; } else { // Count down, not up. for (var index = match.Captures.Count - 1; index >= 0; index--) { var c = match.Captures[index]; text = text.Replace(string.Format(@"${0}", index), c.Value); } return text; } }
/// <summary> /// 查找 /// </summary> private void Match() { if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(pattern)) { return; } StringBuilder builder = new StringBuilder(); try { Match match = Regex.Match(text, pattern); while (match.Success) { System.Console.WriteLine("Match=[" + match + "]"); CaptureCollection cc = match.Captures; foreach (Capture c in cc) { builder.Append("Capture=[" + c + "]"); } builder.Append("\n"); for (int i = 0; i < match.Groups.Count; i++) { System.Text.RegularExpressions.Group group = match.Groups[i]; System.Console.WriteLine("\tGroups[{0}]=[{1}]", i, group); builder.Append("\n"); for (int j = 0; j < group.Captures.Count; j++) { Capture capture = group.Captures[j]; builder.AppendFormat("\t\tCaptures[{0}]=[{1}]", j, capture); } } builder.Append("\n"); match = match.NextMatch(); } matchResult = builder.ToString(); } catch (Exception e) { matchResult = e.Message; } }
/// <summary> /// 说明:除img标签外,去掉所有html标签 /// 作者:李天文 /// 日期:2010-11-8 /// </summary> /// <param name="html">要过滤的字符串</param> /// <returns></returns> public static StringBuilder RetainImg(string html) { StringBuilder str = new StringBuilder(); string pat = @"<img\s.*?\s?src\s*=\s*['|""]?([^\s'""]+).*?>"; Regex r = new Regex(pat, RegexOptions.Compiled); Match m = r.Match(html.ToLower()); string result = string.Empty; while (m.Success) { System.Text.RegularExpressions.Group g = m.Groups[1]; if (g.ToString().IndexOf("/xheditor/xheditor_emot") < 0) { str.Append(g).Append(","); } m = m.NextMatch(); } return(str); }
public static void CreateLayerForCurrentFloor(string layer) { Editor ed = acApp.DocumentManager.MdiActiveDocument.Editor; // Get current floor from current layer name Regex regEx = new Regex(@"\((.+)\)", RegexOptions.IgnoreCase); Match match = regEx.Match(CurrentLayer()); if (match.Success) { System.Text.RegularExpressions.Group group = match.Groups[1]; Int32.TryParse(group.ToString(), out currentFloor); try { CreateLayer(layer + "(" + currentFloor + ")"); return; } catch (System.Exception e) { CreateLayer(layer + "(0)"); ed.WriteMessage("\nProgram exception: " + e.ToString()); return; } } else { try { CreateLayer(layer + "(0)"); } catch (System.Exception) { CreateLayer("0"); ed.WriteMessage("\nWarrning! Layer set to 0. There is no layer " + layer); return; } } return; }
protected override void ExtraVideoMatch(VideoInfo video, GroupCollection matchGroups) { TrackingInfo ti = new TrackingInfo(); // for southpark world System.Text.RegularExpressions.Group epGroup = matchGroups["Episode"]; if (epGroup.Success) { ti.Regex = Regex.Match(epGroup.Value, @"(?<Season>\d\d)(?<Episode>\d\d)"); } // for nl and de if (ti.Season == 0) { ti.Regex = Regex.Match(video.VideoUrl, @"\/S(?<Season>\d{1,3})E(?<Episode>\d{1,3})-", RegexOptions.IgnoreCase); } if (ti.Season != 0) { ti.Title = "South Park"; ti.VideoKind = VideoKind.TvSeries; video.Other = new VideoInfoOtherHelper() { TI = ti }; } else { video.Other = new VideoInfoOtherHelper(); } int time; if (Int32.TryParse(video.Airdate, out time)) { video.Airdate = epoch.AddSeconds(time).ToString(); } }
/// <summary>Gets the components from a URI.</summary> /// <returns>A string that contains the components.</returns> /// <param name="uri">The URI to parse.</param> /// <param name="components">The <see cref="T:System.UriComponents" /> to retrieve from <paramref name="uri" />.</param> /// <param name="format">One of the <see cref="T:System.UriFormat" /> values that controls how special characters are escaped.</param> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="uriFormat" /> is invalid.- or -<paramref name="uriComponents" /> is not a combination of valid <see cref="T:System.UriComponents" /> values. </exception> /// <exception cref="T:System.InvalidOperationException"> /// <paramref name="uri" /> requires user-driven parsing- or -<paramref name="uri" /> is not an absolute URI. Relative URIs cannot be used with this method.</exception> protected internal virtual string GetComponents(System.Uri uri, System.UriComponents components, System.UriFormat format) { if (format < System.UriFormat.UriEscaped || format > System.UriFormat.SafeUnescaped) { throw new ArgumentOutOfRangeException("format"); } System.Text.RegularExpressions.Match match = System.UriParser.uri_regex.Match(uri.OriginalString); string value = this.scheme_name; int defaultPort = this.default_port; if (value == null || value == "*") { value = match.Groups[2].Value; defaultPort = System.Uri.GetDefaultPort(value); } else if (string.Compare(value, match.Groups[2].Value, true) != 0) { throw new SystemException("URI Parser: scheme mismatch: " + value + " vs. " + match.Groups[2].Value); } System.UriComponents uriComponents = components; switch (uriComponents) { case System.UriComponents.Scheme: return(value); case System.UriComponents.UserInfo: return(System.UriParser.ParseAuthority(match.Groups[4]).Groups[2].Value); default: { if (uriComponents == System.UriComponents.Path) { return(this.Format(this.IgnoreFirstCharIf(match.Groups[5].Value, '/'), format)); } if (uriComponents == System.UriComponents.Query) { return(this.Format(match.Groups[7].Value, format)); } if (uriComponents == System.UriComponents.Fragment) { return(this.Format(match.Groups[9].Value, format)); } if (uriComponents != System.UriComponents.StrongPort) { if (uriComponents == System.UriComponents.SerializationInfoString) { components = System.UriComponents.AbsoluteUri; } System.Text.RegularExpressions.Match match2 = System.UriParser.ParseAuthority(match.Groups[4]); StringBuilder stringBuilder = new StringBuilder(); if ((components & System.UriComponents.Scheme) != (System.UriComponents) 0) { stringBuilder.Append(value); stringBuilder.Append(System.Uri.GetSchemeDelimiter(value)); } if ((components & System.UriComponents.UserInfo) != (System.UriComponents) 0) { stringBuilder.Append(match2.Groups[1].Value); } if ((components & System.UriComponents.Host) != (System.UriComponents) 0) { stringBuilder.Append(match2.Groups[3].Value); } if ((components & System.UriComponents.StrongPort) != (System.UriComponents) 0) { System.Text.RegularExpressions.Group group = match2.Groups[4]; stringBuilder.Append((!group.Success) ? (":" + defaultPort) : group.Value); } if ((components & System.UriComponents.Port) != (System.UriComponents) 0) { string value2 = match2.Groups[5].Value; if (value2 != null && value2 != string.Empty && value2 != defaultPort.ToString()) { stringBuilder.Append(match2.Groups[4].Value); } } if ((components & System.UriComponents.Path) != (System.UriComponents) 0) { stringBuilder.Append(match.Groups[5]); } if ((components & System.UriComponents.Query) != (System.UriComponents) 0) { stringBuilder.Append(match.Groups[6]); } if ((components & System.UriComponents.Fragment) != (System.UriComponents) 0) { stringBuilder.Append(match.Groups[8]); } return(this.Format(stringBuilder.ToString(), format)); } System.Text.RegularExpressions.Group group2 = System.UriParser.ParseAuthority(match.Groups[4]).Groups[5]; return((!group2.Success) ? defaultPort.ToString() : group2.Value); } case System.UriComponents.Host: return(System.UriParser.ParseAuthority(match.Groups[4]).Groups[3].Value); case System.UriComponents.Port: { string value3 = System.UriParser.ParseAuthority(match.Groups[4]).Groups[5].Value; if (value3 != null && value3 != string.Empty && value3 != defaultPort.ToString()) { return(value3); } return(string.Empty); } } }
private static System.Text.RegularExpressions.Match ParseAuthority(System.Text.RegularExpressions.Group g) { return(System.UriParser.auth_regex.Match(g.Value)); }