///<summary>
/// This function returns the whole matching path which you have
/// followed to reach the PrefixPhrase.
///</summary>
public void getMatchingPhrase(StringBuilder buffy, String purl, char seperator)
{
String returnValue = "";
int seperatorIndex = purl.IndexOf(seperator);
if (seperatorIndex > 0)
{
String key = purl.Substring(0, seperatorIndex);
String phrase = purl.Substring(seperatorIndex + 1, purl.Length - (seperatorIndex + 1));
PrefixPhrase <O> childPrefixPhrase = childPhraseMap.Get(key);
// now handled inside ChildPrefixMap
// if(childPrefixPhrase==null)
// {
// // try getting it using wildcard as key
// childPrefixPhrase = childPhraseMap.get("*");
// key="*";
// }
if (childPrefixPhrase != null)
{
buffy.Append(returnValue).Append(key).Append(seperator);
buffy.Append(childPrefixPhrase.GetMatchingPhrase(phrase, seperator));
}
}
}
///<summary>
///For put, checks to see if String key is WILDCARD.
///If so, sets special wildcardMatch slot instead of adding to HashMap.
///</summary>
public new PrefixPhrase <O> Add(String key, PrefixPhrase <O> value)
{
PrefixPhrase <O> result;
if (WILDCARD.Equals(key))
{
result = wildcardMatch;
wildcardMatch = value;
return(result);
}
TryGetValue(key, out result);
if (result == null)
{
base.Add(key, value);
result = value;
}
else
{
base.Remove(key);
base.Add(key, value);
}
return(result);
}
public bool Match(ParsedUri purl)
{
String host = purl.Host;
// domainPrefix is a child of this, the root (with no parent)
PrefixPhrase <O> hostPrefix = LookupChild(host);
// children of hostPrefix
return((hostPrefix == null) ? false : hostPrefix.Match(purl.LocalPath, separator)); //edit
}
public PrefixPhrase <O> getMatchingPrefix(ParsedUri purl)
{
String host = purl.Host;
// domainPrefix is a child of this, the root (with no parent)
PrefixPhrase <O> hostPrefix = LookupChild(host);
// children of hostPrefix
String path = purl.AbsolutePath;
return((hostPrefix == null) ? null : hostPrefix.GetMatchingPrefix(path, 1, separator)); // skip over starting '/'
}
public PrefixPhrase <O> Add(ParsedUri purl)
{
String host = purl.Host; //edit
// domainPrefix is a child of this, the root (with no parent)
PrefixPhrase <O> hostPrefix = GetPrefix(null, host);
// children of hostPrefix
String pathStringToParse = usePathFile ? purl.ToString() : purl.LocalPath; //.pathDirectoryString;
return((hostPrefix != null) ? hostPrefix.Add(pathStringToParse, separator) : LookupChild(host));
}
/**
* Seek the PrefixPhrase corresponding to the argument.
* If it does not exist, return it.
* <p/>
* If it does exist, does it have 0 children?
* If so, return null. No need to insert for the argument's phrase.
* If not, return it.
*
* @param prefixPhrase
* @return
*/
protected PrefixPhrase <O> GetPrefix(PrefixPhrase <O> parent, String prefixPhrase)
{
PrefixPhrase <O> preexistingPrefix = childPhraseMap.Get(prefixPhrase); // will match wildcard specially, if this is called for
bool createNew = false;
if (preexistingPrefix == null)
{
preexistingPrefix = new PrefixPhrase <O>(parent, prefixPhrase);
childPhraseMap.Add(prefixPhrase, preexistingPrefix);
createNew = true;
}
if (!createNew && preexistingPrefix.IsTerminal())
{
return(null);
}
return(preexistingPrefix);
}
public PrefixPhrase <O> GetMatchingPrefix(String input, int start, char seperator)
{
if (IsTerminal())
{
return(this);
}
int seperatorIndex = input.IndexOf(seperator, start);
if (seperatorIndex > 0)
{
String key = input.Substring(start, seperatorIndex - start);
PrefixPhrase <O> childPrefixPhrase = childPhraseMap.Get(key);
if (childPrefixPhrase != null)
{
return((seperatorIndex < input.Length) ? childPrefixPhrase.GetMatchingPrefix(input, seperatorIndex + 1, seperator) : this);
}
}
return(null);
}
/**
* Match child prefix by iterating, instead of using HashMap, to avoid allocating substring keys.
*
* @param source String to get key from.
* @param start start of substring for key in string
* @param end end of substring for key in string
*
* @return Matching PrefixPhrase for the substring key from source, or null if there is no match.
*/
private PrefixPhrase <O> MatchChild(String source, int start, int end)
{
// FIXME concurrent modification exception :-(
PrefixPhrase <O> wildcardPhrase = childPhraseMap.WildcardMatch;
if (wildcardPhrase != null)
{
return(wildcardPhrase);
}
foreach (String thatPhrase in childPhraseMap.Keys)
{
if (Match(thatPhrase, source, start, end))
{
return(childPhraseMap.Get(thatPhrase));
}
}
return(null);
}
protected bool Match(String str, int start, char separator)
{
if (IsTerminal())
{
return(true);
}
int end = str.Length;
bool terminate = false;
if (start == end)
{
terminate = true;
}
else
{
if (str[start] == separator)
{
start++;
}
if (start == end)
{
terminate = true;
}
}
if (terminate)
{
return(false);
}
int nextSeparator = str.IndexOf(separator, start);
if (nextSeparator == -1)
{
nextSeparator = end;
}
// String phraseString = string.substring(start, nextSeparator);
// PrefixPhrase nextPrefixPhrase = lookupChild(phraseString);
PrefixPhrase <O> nextPrefixPhrase = MatchChild(str, start, nextSeparator);
return((nextPrefixPhrase != null) && nextPrefixPhrase.Match(str, nextSeparator, separator));
}
protected PrefixPhrase <O> Add(String str, int start, char separator)
{
int end = str.Length;
bool terminate = false;
if (start == end)
{
terminate = true;
}
else
{
if (str[start] == separator)
{
start++;
}
if (start == end)
{
terminate = true;
}
}
if (terminate)
{
Clear();
return(this);
}
int nextSeparator = str.IndexOf(separator, start);
if (nextSeparator == -1)
{
nextSeparator = end;
}
if (nextSeparator > -1)
{
String phraseString = str.Substring(start, nextSeparator - start);
// extra round of messing with synch, because we need to know if we
// are creating a new Phrase
PrefixPhrase <O> nextPrefixPhrase = GetPrefix(this, phraseString);
if (nextPrefixPhrase != null)
{
return(nextPrefixPhrase.Add(str, nextSeparator, separator));
}
else
{
// done!
PrefixPhrase <O> newTerminal = LookupChild(phraseString);
//newTerminal.clear();
return(newTerminal);
// synchronized (this)
// {
// nextPrefixPhrase = getPrefix(this, phraseString);
// if (nextPrefixPhrase == null)
// {
// nextPrefixPhrase = childPhraseMap.getOrCreateAndPutIfNew(phraseString, this);
// result = nextPrefixPhrase;
// }
// }
}
}
else
{
Debug.WriteLine("help! wrong block!!!");
// last segment
return(null);
}
}
public PrefixPhrase(PrefixPhrase <O> parent, String phrase)
{
this.parent = parent;
this.phrase = phrase;
}