// Set the pattern to use public bool SetPattern(ktString Pattern) { RegexOptions Opt = new RegexOptions(); switch (m_Mode) { case ktRE_Mode.PERL: { ktString OPattern = new ktString(Pattern); char Delim = Pattern.First(); Pattern.RemoveFirst(); int Pos = Find(Pattern, @"[^\\]" + Delim.ToString()); if (Pos < 0) { throw new ktError("ktRegEx::SetPattern() : The pattern isn't Perl compatible (" + OPattern + ")", ktERR.NOTFOUND); } else { Pos++; } ktString Modifiers = Pattern.SubStr(Pos + 1); Pattern.Remove((uint)Pos); for (uint I = 0; I < Modifiers.Len(); I++) { // Console.Write( Modifiers[I].ToString() + ";" ); switch (Modifiers[I]) { case 'i': { Opt = Opt | RegexOptions.IgnoreCase; break; } case 'm': { Opt = Opt | RegexOptions.Multiline; break; } case 'x': { Opt = Opt | RegexOptions.IgnorePatternWhitespace; break; } case 'A': { if (Pattern.First() != '^') { Pattern.Prepend("^"); } break; }/* case 'i': { Opt = Opt | RegexOptions.IgnoreCase; break; }*/ } } break; } case ktRE_Mode.Plain: { break; } default: { throw new ktError("ktRegExp::SetPattern(): The mode '" + GetModeAsString() + "' is not implementet yet!", ktERR.NOTIMP); } } // Set the pattern m_Pattern = Pattern; // Take care of the (if any) exception try { // Create the (internal) regex object m_P = new Regex(m_Pattern.GetValue(), Opt); } catch (ktError Ex) { SetError("Couldn't set pattern and create a new (internal) Regex object" + Ex.Message, ktERR.REGEX_COULDNT_SET_PATTERN); return false; } catch (Exception Ex) { SetError("Couldn't set pattern and create a new (internal) Regex object" + Ex.Message, ktERR.REGEX_COULDNT_SET_PATTERN); return false; } return true; }
// Match a pattern against a value (static!) public static bool Matches(ktString Pattern, ktString Value, ktRE_Mode Mode) { // "Init" the object Regex RegObj; // Check which mode to use // If we should use the mode "plain" if (Mode == ktRE_Mode.Plain) { // Create the (internal) regex object using the givven pattern RegObj = new Regex(Pattern.GetValue()); // Doesn't support the mode for now } else { // We set an error that we doesn't support the choosed mode // (should we throw and exception???) /*SetError( "ktRegExp::Match() : The mode '" + GetModeAsString().GetValue() + "' is not implementet yet!", ktERR.NOTIMP );*/ return false; } // Do the match... return RegObj.IsMatch(Value.GetValue()); }
// Match a value against the storred pattern public bool IsMatch(ktString Value, int Start) { // If we have a pattern?! if ((m_Pattern.IsEmpty()) || (m_P == null)) { // Set error (throw exeption??) and return false SetError("ktRegExp::IsMatch(): The pattern is not set!", ktERR.NOTSET); return false; } return m_P.IsMatch(Value.GetValue(), Start); }
// Check if the string Is one word (checks if it only include A-Z,a-z and any // characters that may be added, default: '_' [underscore]) // OBS! This function doesn'T alowe spaces (even if it's added using 'AddedChars') public bool IsWord(ktString AddedChars) { bool Res = true; // We simply use IsAlpha() to check if it's valid Res = IsAlpha(AddedChars.GetValue()); // If IsAlpha() OK'd the string // Check for spaces... if ((Res) && (Contains(" "))) { // Find space and that's not allowed... Res = false; } return Res; }
// Match and compare... // Find, but with a mask (using ? and *) public bool Matches(ktString Mask) { /* ** <note> For now we just cross our fingers and hopes that this function (/method?) actually works. We haven't runned this code yet. (BTW this goes with most of the whole class...)</note> ***/ bool Match = false; bool GoOn = true; int Pos; ktTripple Joker = 0; // 1 == * and 2 == ? ktString MatchTmp; ktString Str = new ktString(GetValue()); // Don't stop until we say so while (GoOn) { Joker = 0; // If there's no more "Joker" if ((Pos = ktRegEx.Find(Mask.GetValue(), "\\*|\\?")) < 0) { // If (the rest of) the mask matches the string if (Mask == Str) { // Stop looping GoOn = false; // And "OK it" Match = true; } else { // Stop looping GoOn = false; // Didn' match... Match = false; } } else { // Find a "Joker" and get everything infront of it MatchTmp = Mask.SubStr(0, Pos); // Remove what we got from the mask Mask.Remove(0, MatchTmp.Length()); // Chech the "Joker" // If the first char is * in the "new mask" // then indicate that if (Mask.First() == '*') Joker = 1; // Or if it's ?... else Joker = 2; // Remove the "Joker" Mask.RemoveFirst(); // If this part of the mask doesn't match... (simply not a match) if ((!MatchTmp.IsEmpty()) && (MatchTmp != Str.SubStr(0, MatchTmp.Length()))) { // Stop looping GoOn = false; Match = false; } else { // As we now that this part of the mask matches the string // Remove that part from the string Str.Remove(0, MatchTmp.Length()); // If the "Joker" is * if (Joker == 1) { // Get the position of the next "Joker" Pos = ktRegEx.Find(Mask.GetValue(), "\\*|\\?"); // If we didn't find a new "Joker" if (Pos < 0) { // get the length of the rest of the mask ("find the end") Pos = Mask.Length(); // If Pos is 0 if (Pos == 0) // No more mask... Pos = -1; } // If Pos is less than 0 // This (should) means that the * was the last thing in // the mask and should therefor match the rest of the string if (Pos < 0) { // Stop looping GoOn = false; // It's a match... Match = true; } else { // Get the next part of the mask MatchTmp = Mask.SubStr(0, Pos); // Remove that part of the mask... Mask.Remove(0, Pos); // If the "submask" matches the corresponding "substring" if ((Pos = Str.Find(MatchTmp)) >= 0) { // The substring matched... Match = true; // Remove the matched "substring" Str.Remove(0, Pos + MatchTmp.Length()); // If the mask now is empty if (Mask.IsEmpty()) { // Stop looping GoOn = false; // If the string isn't empty if (!Str.IsEmpty()) // As the mask is empty but not the // the string, it means that it's // an missmatch... Match = false; } // It wasn't a match (the match failed... } else { // Stop looping GoOn = false; Match = false; } } // If the "Joker" is ? } else { // Just remove the first char Str.RemoveFirst(); // As the mask has matched so far... Match = true; } } } // If the mask is empty (and we can go on) // Means that the mask matched the string if (((Str == "") || (Mask == "")) && (GoOn)) { // Stop looping GoOn = false; // And "OK it" Match = true; } } return Match; }
// Get string before the last occurence of the // substring that Is supplied public ktString BeforeLast(ktString Str) { // Get the position for the last occurence of 'Str' int Pos = m_Content.LastIndexOf(Str.GetValue()); if (Pos < 0) Pos = Length() - 1; // Get everything before that occurence return Left((uint)Pos); }
// Compare the string with 'Str' (ref. strcmp) (case-sensitive) public int Cmp(ktString Str) { return String.Compare(Str.GetValue(), m_Content); }
// String value tampering // Appends (concate, in the end) a string to the string // returns a reference to the string public ktString Append(ktString Str) { return Append(Str.GetValue()); }
// Get string before the First occurence of the // substring that Is supplied public ktString BeforeFirst(ktString Str) { // Get the position for the first occurence of 'Str' int Pos = m_Content.IndexOf(Str.GetValue()); if (Pos < 0) Pos = 0; // Get everything before that position return Left((uint)Pos); }
// Trim the string (remove whitespaces etc, from the beginning and/or end) public ktString Trim(ktStripType St, ktString WS) { if ((St == ktStripType.both) || (St == ktStripType.leading)) { m_Content = m_Content.TrimStart(WS.GetValue().ToCharArray()); } if ((St == ktStripType.both) || (St == ktStripType.trailing)) { m_Content = m_Content.TrimEnd(WS.GetValue().ToCharArray()); } return this; }
// Same as above but this function(s) returns the string // instead of change the string in the object... public static ktString Format(ktString Format, params object[] ParamList) { return new ktString(string.Format(Format.GetValue(), ParamList)); }
public ktString Strip(ktStripType St, ktString Delim) { string Str = m_Content; if ((St == ktStripType.both) || (St == ktStripType.leading)) { Str = Str.TrimStart(Delim.GetValue().ToCharArray()); } if ((St == ktStripType.both) || (St == ktStripType.trailing)) { Str = Str.TrimEnd(Delim.GetValue().ToCharArray()); } return new ktString(Str); }
// Set the value of the string, from ktString format public void SetValue(ktString Str) { if (((object)Str) == null) { m_Content = ""; } else { m_Content = Str.GetValue(); } }
// Replace First (or all) occurrences of substring with another one. // (returns number of replacements) public int Replace(ktString OldString, ktString NewString, bool ReplaceAll) { // Init Variables int Count = 0; string Tmp; int Pos, tPos = 0; // Get the first position Pos = tPos = Find(OldString); // Go on as long as we can find 'OldString' while (tPos >= 0) { // Cut out everything before the 'OldString' Tmp = m_Content.Substring(0, Pos); // Insert 'NewString' (I.e. replace) Tmp = Tmp + NewString.GetValue(); // Append everything after 'OldString' Tmp = Tmp + m_Content.Substring(Pos + OldString.Length()); // Save m_Content = Tmp; // Find the next position tPos = SubStr(Pos + NewString.Length()).Find(OldString); Pos = Pos + NewString.Length() + tPos; // Count how many replaces we made Count++; // If we only should replace the first occurence of 'OldString' if (!ReplaceAll) // Stop (-1 indicates that we didn't find 'OldString' again) Pos = -1; } // Return the Count return Count; }
// Set the value of the string using "format" (as printf or string::format) public ktString Printf(ktString Format, params object[] ParamList) { m_Content = string.Format(Format.GetValue(), ParamList); return this; }
// Appends (concate, in the end) a string to the string // returns a reference to the string public ktString Prepend(ktString Str) { return Prepend(Str.GetValue()); }