public static Dictionary<ktString, ktString> ParseInfoString( ktString InfoStr )
{
int p = 0, p2 = 0;
ktString property;
ktString prop_name, prop_value;
Dictionary<ktString, ktString> InfoMap = new Dictionary<ktString, ktString>();
while (!InfoStr.IsEmpty())
{
p = InfoStr.IndexOf(';');
if (p < 0)
{
property = InfoStr;
p = InfoStr.Length() - 1;
}
else
{
property = InfoStr.SubString(0, p).Trim();
}
p2 = property.IndexOf('=');
prop_name = property.SubString(0, p2).AsUpper();
prop_value = property.SubString(p2 + 1);
InfoMap.Add(prop_name, prop_value);
InfoStr.Remove(0, p + 1);
InfoStr = InfoStr.Trim();
}
return InfoMap;
}
// 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 the number of occurrenses of a substring in the string
public int Freq(ktString Str)
{
int Cnt = 0;
// Go thru the string
for (int I = 0; I < Length(); I++)
{
// Found a occurence
if (SubStr(I, Str.Length()) == Str)
{
// Skip the occurence..
// We don't want to Count all occurences of "ab" (for instance)
// when we're looking for "abab"
I += Str.Length() - 1;
// Count it...
Cnt++;
}
}
return Cnt;
}
// Search Functions
// Find a substring in the string
// either search front-to-end (default) or end-to-front
public int Find(ktString Needle, bool FromEnd)
{
int Pos = -1;
int AddI = 1, StartI = 0, StopI = Length() -1;
// If we should go backwards...
if (FromEnd)
{
// Go backwards (Count down)
AddI = -1;
// start at the end
StartI = Length() - Needle.Length();
// Stop in the beginning
StopI = 1;
}
// Go thru all characters (either forward or reverse...)
for (int I = StartI; ((AddI * I) <= StopI) && (Pos < 0); I += AddI)
{
// If we found an occurence
if (SubStr(I, Needle.Length()) == Needle)
{
// Save it's position
Pos = I;
}
}
// Return the position
return Pos;
}
// Check if the string contains the substring Str
public bool StartsWith(ktString Str, out ktString Rest)
{
bool Ret = false;
if ((Length() >= Str.Length()) &&
(Str == SubStr(0, Str.Length())))
{
Ret = true;
Rest = SubStr(Str.Length());
}
else
Rest = "";
return Ret;
}
// 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;
}