|
public getClone ( |
||
| token | ||
| return | ||
public override LexiconToken getClone(LexiconToken token)
{
LexiconLiteral literalToReplace = new LexiconLiteral();
literalToReplace.URI = token.URI;
literalToReplace.label = token.label;
literalToReplace.typeOfOwner = (token as LexiconLiteral).typeOfOwner.ToList();
literalToReplace.QuestionMatch = token.QuestionMatch;
literalToReplace.score = token.score;
return literalToReplace;
}
/// removing the non used predicates domains and the literals type of owners
/// </summary>
/// <param name="tokens">list </param>of tokens
/// <returns>cleaned list of tokens </returns>
private List <QueryBucket> cleanBucket(List <QueryBucket> queryBuckets)
{
#region removing Buckets which still have question left >1
foreach (QueryBucket querybucket in queryBuckets.ToList())
{
if (querybucket.questionLeft.Length > 0)
{
queryBuckets.Remove(querybucket);
}
}
#endregion
#region remove Predicates domains and type of owners
foreach (QueryBucket bucket in queryBuckets.ToList())
{
//adding predicates and literals to a list
List <LexiconPredicate> predicateList = new List <LexiconPredicate>();
List <LexiconLiteral> literalList = new List <LexiconLiteral>();
foreach (LexiconToken token in bucket.tokens)
{
if (token is LexiconPredicate)
{
predicateList.Add(token as LexiconPredicate);
}
if (token is LexiconLiteral)
{
literalList.Add(token as LexiconLiteral);
}
}
if (predicateList.Count > 0)
{
//removing domains and ranges that are not used
foreach (LexiconToken token in bucket.tokens.ToList())
{
if (token is LexiconPredicate)
{
//casting the lexicontoken to lexicon predicate
LexiconPredicate oldPredicate = token as LexiconPredicate;
//cloning the token to be modified
LexiconPredicate predicateToReplace = (LexiconPredicate)token.getClone(token);
foreach (string oldPredDomain in oldPredicate.domains.ToList())
{
bool exist = false;
foreach (LexiconLiteral tmpliteral in literalList)
{
if (tmpliteral.typeOfOwner.Contains(oldPredDomain))
{
exist = true;
}
}
//if this domains doesn't contained in any of literals type of owners remove it as it wont match|join with anything
if (!exist)
{
//old bucket = new bucket and then modify in the new in order then to be able to remove the old
predicateToReplace = oldPredicate.getClone(oldPredicate) as LexiconPredicate;
//removing domain not used
predicateToReplace.domains.Remove(oldPredDomain);
//remove the old bucket and replace it with new modified one // needed because of reference issues
bucket.tokens.Remove(oldPredicate);
bucket.tokens.Add(predicateToReplace);
oldPredicate = predicateToReplace;
//remove the predicate if it doesnt have any domains left
if (oldPredicate.domains.Count == 0)
{
bucket.tokens.Remove(oldPredicate);
predicateList.Remove(oldPredicate as LexiconPredicate);
//remove the bucket if it's free from predicates
if (bucket.tokens.Count == 0)
{
queryBuckets.Remove(bucket);
}
}
}
}
}
if (token is LexiconLiteral)
{
LexiconLiteral oldLiteral = token as LexiconLiteral;
LexiconLiteral newLiteral = token.getClone(token) as LexiconLiteral;
foreach (string typeofowner in oldLiteral.typeOfOwner.ToList())
{
bool exist = false;
foreach (LexiconPredicate tmmpredicate in predicateList)
{
if (tmmpredicate.domains.Contains(typeofowner))
{
exist = true;
}
}
if (!exist)
{
//taking a copy from the old literal in order to remove it from the bucket when replacing it with the newliteral
newLiteral = oldLiteral.getClone(oldLiteral) as LexiconLiteral;
// removing typeofowner not used
newLiteral.typeOfOwner.Remove(typeofowner);
// updating the bucket tokens by replacing the old literal with the new one
bucket.tokens.Remove(oldLiteral);
bucket.tokens.Add(newLiteral);
oldLiteral = newLiteral;
if (oldLiteral.typeOfOwner.Count == 0)
{
bucket.tokens.Remove(oldLiteral);
literalList.Remove(oldLiteral as LexiconLiteral);
//remove the bucket if it's free from Tokens
if (bucket.tokens.Count == 0)
{
queryBuckets.Remove(bucket);
}
}
}
}
}
}
}
else
{
bucket.literalOnly = true;
}
}
#endregion
#region remove the multiple domains and multiple ranges
foreach (QueryBucket bucket in queryBuckets)
{
foreach (LexiconToken predicateToken in bucket.tokens)
{
if (predicateToken is LexiconPredicate)
{
foreach (LexiconToken literalToken in bucket.tokens)
{
if (literalToken is LexiconLiteral && Enumerable.SequenceEqual((predicateToken as LexiconPredicate).domains, (literalToken as LexiconLiteral).typeOfOwner))
{
(predicateToken as LexiconPredicate).domains.RemoveRange(1, (predicateToken as LexiconPredicate).domains.Count - 1);
(literalToken as LexiconLiteral).typeOfOwner.RemoveRange(1, (literalToken as LexiconLiteral).typeOfOwner.Count - 1);
}
}
}
}
}
#endregion
return(queryBuckets);
}
