/// <summary>
/// Gets a ResultSet containing all entries sorted by lexical form for a given writing system.
/// Use "Form" to access the lexical form in a RecordToken.
/// </summary>
/// <param name="writingSystemDefinition"></param>
/// <returns></returns>
private ResultSet <LexEntry> GetAllEntriesSortedByLexicalForm(WritingSystemDefinition writingSystemDefinition)
{
if (writingSystemDefinition == null)
{
throw new ArgumentNullException("writingSystemDefinition");
}
string cacheName = String.Format("sortedByLexicalForm_{0}", writingSystemDefinition.LanguageTag);
if (_caches[cacheName] == null)
{
var lexicalFormQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entryToQuery)
{
var tokenFieldsAndValues = new Dictionary <string, object>();
string headWord = entryToQuery.LexicalForm[writingSystemDefinition.LanguageTag];
if (String.IsNullOrEmpty(headWord))
{
headWord = null;
}
tokenFieldsAndValues.Add("Form", headWord);
return(new[] { tokenFieldsAndValues });
});
ResultSet <LexEntry> itemsMatching = _decoratedDataMapper.GetItemsMatching(lexicalFormQuery);
var sortOrder = new SortDefinition[1];
sortOrder[0] = new SortDefinition("Form", writingSystemDefinition.DefaultCollation.Collator);
_caches.Add(cacheName, new ResultSetCache <LexEntry>(this, sortOrder, itemsMatching, lexicalFormQuery));
}
ResultSet <LexEntry> resultsFromCache = _caches[cacheName].GetResultSet();
return(resultsFromCache);
}
private ResultSet <LexEntry> GetAllEntriesWithMeaningsSortedByLexicalForm(IWritingSystemDefinition lexicalUnitWritingSystem, bool glossMeaningField)
{
if (lexicalUnitWritingSystem == null)
{
throw new ArgumentNullException("lexicalUnitWritingSystem");
}
string cachename = String.Format("MeaningsSortedByLexicalForm_{0}", lexicalUnitWritingSystem);
if (_caches[cachename] == null)
{
DelegateQuery <LexEntry> MatchingMeaningQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entry)
{
List <IDictionary <string, object> > fieldsandValuesForRecordTokens = new List <IDictionary <string, object> >();
int senseNumber = 0;
foreach (LexSense sense in entry.Senses)
{
foreach (LanguageForm form in glossMeaningField ? sense.Gloss.Forms : sense.Definition.Forms)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
string lexicalForm = entry.LexicalForm[lexicalUnitWritingSystem.Id];
if (String.IsNullOrEmpty(lexicalForm))
{
lexicalForm = null;
}
tokenFieldsAndValues.Add("Form", lexicalForm);
string meaning = form.Form;
if (String.IsNullOrEmpty(meaning))
{
meaning = null;
}
tokenFieldsAndValues.Add("Meaning", meaning);
string meaningWritingSystem = form.WritingSystemId;
if (String.IsNullOrEmpty(meaningWritingSystem))
{
meaningWritingSystem = null;
}
tokenFieldsAndValues.Add("MeaningWritingSystem", meaningWritingSystem);
tokenFieldsAndValues.Add("SenseNumber", senseNumber);
fieldsandValuesForRecordTokens.Add(tokenFieldsAndValues);
}
senseNumber++;
}
return(fieldsandValuesForRecordTokens);
}
);
ResultSet <LexEntry> itemsMatchingQuery = GetItemsMatching(MatchingMeaningQuery);
SortDefinition[] sortDefinition = new SortDefinition[4];
sortDefinition[0] = new SortDefinition("Form", lexicalUnitWritingSystem.Collator);
sortDefinition[1] = new SortDefinition("Meaning", StringComparer.InvariantCulture);
sortDefinition[2] = new SortDefinition("MeaningWritingSystem", StringComparer.InvariantCulture);
sortDefinition[3] = new SortDefinition("SenseNumber", Comparer <int> .Default);
ResultSetCache <LexEntry> cache =
new ResultSetCache <LexEntry>(this, sortDefinition, itemsMatchingQuery, MatchingMeaningQuery);
_caches.Add(cachename, cache);
}
return(_caches[cachename].GetResultSet());
}
/// <summary>
/// Gets a ResultSet containing all entries sorted by definition and gloss. It will return both the definition
/// and the gloss if both exist and are different.
/// Use "Form" to access the Definition/Gloss in RecordToken.
/// </summary>
/// <param name="writingSystemDefinition"></param>
/// <returns>Definition and gloss in "Form" field of RecordToken</returns>
public ResultSet <LexEntry> GetAllEntriesSortedByDefinitionOrGloss(WritingSystemDefinition writingSystemDefinition)
{
if (writingSystemDefinition == null)
{
throw new ArgumentNullException("writingSystemDefinition");
}
string cacheName = String.Format("SortByDefinition_{0}", writingSystemDefinition.LanguageTag);
if (_caches[cacheName] == null)
{
var definitionQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entryToQuery)
{
var fieldsandValuesForRecordTokens = new List <IDictionary <string, object> >();
int senseNumber = 0;
foreach (LexSense sense in entryToQuery.Senses)
{
var rawDefinition = sense.Definition[writingSystemDefinition.LanguageTag];
var definitions = GetTrimmedElementsSeperatedBySemiColon(rawDefinition);
var rawGloss = sense.Gloss[writingSystemDefinition.LanguageTag];
var glosses = GetTrimmedElementsSeperatedBySemiColon(rawGloss);
var definitionAndGlosses = MergeListsWhileExcludingDoublesAndEmptyStrings(definitions, glosses);
if (definitionAndGlosses.Count == 0)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
tokenFieldsAndValues.Add("Form", null);
tokenFieldsAndValues.Add("Sense", senseNumber);
fieldsandValuesForRecordTokens.Add(tokenFieldsAndValues);
}
else
{
foreach (string definition in definitionAndGlosses)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
tokenFieldsAndValues.Add("Form", definition);
tokenFieldsAndValues.Add("Sense", senseNumber);
fieldsandValuesForRecordTokens.Add(tokenFieldsAndValues);
}
}
senseNumber++;
}
return(fieldsandValuesForRecordTokens);
});
ResultSet <LexEntry> itemsMatching = _decoratedDataMapper.GetItemsMatching(definitionQuery);
var sortOrder = new SortDefinition[2];
sortOrder[0] = new SortDefinition("Form", writingSystemDefinition.DefaultCollation.Collator);
sortOrder[1] = new SortDefinition("Sense", Comparer <int> .Default);
_caches.Add(cacheName, new ResultSetCache <LexEntry>(this, sortOrder, itemsMatching, definitionQuery));
}
return(_caches[cacheName].GetResultSet());
}
/// <summary>
/// Gets a ResultSet containing entries that contain a semantic domain assigned to them
/// sorted by semantic domain.
/// Use "SemanticDomain" to access the semantic domain in a RecordToken.
/// </summary>
/// <param name="fieldName"></param>
/// <returns></returns>
public ResultSet <LexEntry> GetEntriesWithSemanticDomainSortedBySemanticDomain(
string fieldName)
{
if (fieldName == null)
{
throw new ArgumentNullException("fieldName");
}
string cachename = String.Format("Semanticdomains_{0}", fieldName);
if (_caches[cachename] == null)
{
var semanticDomainsQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entry)
{
var fieldsandValuesForRecordTokens = new List <IDictionary <string, object> >();
foreach (LexSense sense in entry.Senses)
{
foreach (KeyValuePair <string, IPalasoDataObjectProperty> pair in sense.Properties)
{
if (pair.Key == fieldName)
{
var semanticDomains = (OptionRefCollection)pair.Value;
foreach (string semanticDomain in semanticDomains.Keys)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
string domain = semanticDomain;
if (String.IsNullOrEmpty(semanticDomain))
{
domain = null;
}
if (CheckIfTokenHasAlreadyBeenReturnedForThisSemanticDomain(fieldsandValuesForRecordTokens, domain))
{
continue; //This is to avoid duplicates
}
tokenFieldsAndValues.Add("SemanticDomain", domain);
fieldsandValuesForRecordTokens.Add(tokenFieldsAndValues);
}
}
}
}
return(fieldsandValuesForRecordTokens);
}
);
ResultSet <LexEntry> itemsMatchingQuery = GetItemsMatching(semanticDomainsQuery);
var sortDefinition = new SortDefinition[2];
sortDefinition[0] = new SortDefinition("SemanticDomain", StringComparer.InvariantCulture);
sortDefinition[1] = new SortDefinition("Sense", Comparer <int> .Default);
var cache =
new ResultSetCache <LexEntry>(this, sortDefinition, itemsMatchingQuery, semanticDomainsQuery);
_caches.Add(cachename, cache);
}
return(_caches[cachename].GetResultSet());
}
public void TouchAndSaveEntriesFromQuery(DelegateQuery <LexEntry> xrefQuery, string propertyModified)
{
ResultSet <LexEntry> all_xref = GetItemsMatching(xrefQuery);
IList <LexEntry> entries = new List <LexEntry>();;
foreach (RecordToken <LexEntry> token in all_xref)
{
LexEntry entry = token.RealObject;
entry.SomethingWasModified(propertyModified);
entries.Add(entry);
}
SaveItems(entries);
}
/// <summary>
/// Gets a ResultSet containing all entries sorted by lexical form for a given writing system.
/// If a lexical form for a given writingsystem does not exist we substitute one from another writingsystem.
/// Use "Form" to access the lexical form in a RecordToken.
/// </summary>
/// <param name="writingSystemDefinition"></param>
/// <returns></returns>
public ResultSet <LexEntry> GetAllEntriesSortedByLexicalFormOrAlternative(WritingSystemDefinition writingSystemDefinition)
{
if (writingSystemDefinition == null)
{
throw new ArgumentNullException("writingSystemDefinition");
}
string cacheName = String.Format("sortedByLexicalFormOrAlternative_{0}", writingSystemDefinition.LanguageTag);
if (_caches[cacheName] == null)
{
var lexicalFormWithAlternativeQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entryToQuery)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
string lexicalform = entryToQuery.LexicalForm[writingSystemDefinition.LanguageTag];
string writingSystemOfForm = writingSystemDefinition.LanguageTag;
if (lexicalform == "")
{
lexicalform = entryToQuery.LexicalForm.GetBestAlternative(writingSystemDefinition.LanguageTag);
foreach (LanguageForm form in entryToQuery.LexicalForm.Forms)
{
if (form.Form == lexicalform)
{
writingSystemOfForm = form.WritingSystemId;
}
}
if (lexicalform == "")
{
lexicalform = null;
}
}
tokenFieldsAndValues.Add("Form", lexicalform);
tokenFieldsAndValues.Add("WritingSystem", writingSystemOfForm);
return(new[] { tokenFieldsAndValues });
});
ResultSet <LexEntry> itemsMatching = _decoratedDataMapper.GetItemsMatching(lexicalFormWithAlternativeQuery);
var sortOrder = new SortDefinition[1];
sortOrder[0] = new SortDefinition("Form", writingSystemDefinition.DefaultCollation.Collator);
_caches.Add(cacheName, new ResultSetCache <LexEntry>(this, sortOrder, itemsMatching, lexicalFormWithAlternativeQuery));
}
ResultSet <LexEntry> resultsFromCache = _caches[cacheName].GetResultSet();
return(resultsFromCache);
}
public ResultSet <LexEntry> GetEntriesWithMissingFieldSortedByLexicalUnit(MissingFieldQuery query, IWritingSystemDefinition lexicalUnitWritingSystem)
{
Guard.AgainstNull(lexicalUnitWritingSystem, "lexicalUnitWritingSystem");
Guard.AgainstNull(query.Field, "field");
Guard.AgainstNull(query, "query");
string cacheName = String.Format("missingFieldsSortedByLexicalForm_{0}_{1}_{2}", query.Field, lexicalUnitWritingSystem.Id, query.UniqueCacheId);
//cacheName = MakeSafeForFileName(cacheName);
if (_caches[cacheName] == null)
{
DelegateQuery <LexEntry> lexicalFormQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entryToQuery)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
if (query.FilteringPredicate(entryToQuery))
{
string lexicalForm = null;
if (!String.IsNullOrEmpty(entryToQuery.LexicalForm[lexicalUnitWritingSystem.Id]))
{
lexicalForm = entryToQuery.LexicalForm[lexicalUnitWritingSystem.Id];
}
tokenFieldsAndValues.Add("Form", lexicalForm);
return(new IDictionary <string, object>[] { tokenFieldsAndValues });
}
return(new IDictionary <string, object> [0]);
});
ResultSet <LexEntry> itemsMatching = _decoratedDataMapper.GetItemsMatching(lexicalFormQuery);
SortDefinition[] sortOrder = new SortDefinition[1];
sortOrder[0] = new SortDefinition("Form", lexicalUnitWritingSystem.Collator);
_caches.Add(cacheName, new ResultSetCache <LexEntry>(this, sortOrder, itemsMatching, lexicalFormQuery));
}
ResultSet <LexEntry> resultsFromCache = _caches[cacheName].GetResultSet();
return(resultsFromCache);
}
private ResultSet <LexEntry> GetAllEntriesSortedById()
{
string cacheName = String.Format("sortedById");
if (_caches[cacheName] == null)
{
var IdQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entryToQuery)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
tokenFieldsAndValues.Add("Id", entryToQuery.Id);
return(new[] { tokenFieldsAndValues });
});
ResultSet <LexEntry> itemsMatching = _decoratedDataMapper.GetItemsMatching(IdQuery);
var sortOrder = new SortDefinition[1];
sortOrder[0] = new SortDefinition("Id", Comparer <string> .Default);
_caches.Add(cacheName, new ResultSetCache <LexEntry>(this, sortOrder, itemsMatching, IdQuery));
}
ResultSet <LexEntry> resultsFromCache = _caches[cacheName].GetResultSet();
return(resultsFromCache);
}
/// <summary>
/// Gets a ResultSet containing all entries sorted by citation if one exists and otherwise
/// by lexical form.
/// Use "Form" to access the headword in a RecordToken.
/// </summary>
/// <param name="writingSystemDefinition"></param>
/// <returns></returns>
public ResultSet <LexEntry> GetAllEntriesSortedByHeadword(WritingSystemDefinition writingSystemDefinition)
{
if (writingSystemDefinition == null)
{
throw new ArgumentNullException("writingSystemDefinition");
}
string cacheName = String.Format("sortedByHeadWord_{0}", writingSystemDefinition.LanguageTag);
if (_caches[cacheName] == null)
{
var headWordQuery = new DelegateQuery <LexEntry>(
delegate(LexEntry entryToQuery)
{
IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
string headWord = entryToQuery.VirtualHeadWord[writingSystemDefinition.LanguageTag];
if (String.IsNullOrEmpty(headWord))
{
headWord = null;
}
tokenFieldsAndValues.Add("Form", headWord);
return(new[] { tokenFieldsAndValues });
});
ResultSet <LexEntry> itemsMatching = _decoratedDataMapper.GetItemsMatching(headWordQuery);
var sortOrder = new SortDefinition[4];
sortOrder[0] = new SortDefinition("Form", writingSystemDefinition.DefaultCollation.Collator);
sortOrder[1] = new SortDefinition("OrderForRoundTripping", Comparer <int> .Default);
sortOrder[2] = new SortDefinition("OrderInFile", Comparer <int> .Default);
sortOrder[3] = new SortDefinition("CreationTime", Comparer <DateTime> .Default);
_caches.Add(cacheName, new ResultSetCache <LexEntry>(this, sortOrder, itemsMatching, headWordQuery));
// _caches.Add(headWordQuery, /* itemsMatching */ results); // review cp Refactor caches to this signature.
}
ResultSet <LexEntry> resultsFromCache = _caches[cacheName].GetResultSet();
string previousHeadWord = null;
int homographNumber = 1;
RecordToken <LexEntry> previousToken = null;
foreach (RecordToken <LexEntry> token in resultsFromCache)
{
// A null Form indicates there is no HeadWord in this writing system.
// However, we need to ensure that we return all entries, so the AtLeastOne in the query
// above ensures that we keep it in the result set with a null Form and null WritingSystemId.
var currentHeadWord = (string)token["Form"];
if (string.IsNullOrEmpty(currentHeadWord))
{
token["HasHomograph"] = false;
token["HomographNumber"] = 0;
continue;
}
if (currentHeadWord == previousHeadWord)
{
homographNumber++;
}
else
{
previousHeadWord = currentHeadWord;
homographNumber = 1;
}
// only used to get our sort correct --This comment seems nonsensical --TA 2008-08-14!!!
token["HomographNumber"] = homographNumber;
switch (homographNumber)
{
case 1:
token["HasHomograph"] = false;
break;
case 2:
Debug.Assert(previousToken != null);
previousToken["HasHomograph"] = true;
token["HasHomograph"] = true;
break;
default:
token["HasHomograph"] = true;
break;
}
previousToken = token;
}
return(resultsFromCache);
}
