/// <summary>
/// Sets the word using autoconversion method, if enabled
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public translationTextTableEntryEnum SetWord(string key)
{
lock (SetWordLock)
{
if (!isAutoConversionEnabled)
{
throw new dataException("Can't set word with SetWord(" + key + ") method because the conversion method was not specified");
}
translationTextTableEntryEnum entry = checkForEntry(key);
if (entry == translationTextTableEntryEnum.unknownEntry || entry == translationTextTableEntryEnum.valueEntry)
{
if (isAutoConversionEnabled)
{
string k = key;
string v = conversionMethod(key);
if (k != v)
{
Add(key, conversionMethod(key));
return translationTextTableEntryEnum.newEntry;
}
else
{
return translationTextTableEntryEnum.none;
}
}
}
}
return translationTextTableEntryEnum.none;
}
/// <summary>
/// Gets the word pair either the specified <c>key</c> was found as Key or Value, otherwise returns the <c>key</c> or makes auto conversion if <see cref="isAutoConversionEnabled" /> i.e. <see cref="conversionMethod" /> provided with <see cref="translationTextTable" /> constructor
/// </summary>
/// <param name="key">The key.</param>
/// <param name="oentry">Provides insight how word was found/converted</param>
/// <returns></returns>
public string GetWord(string key, out translationTextTableEntryEnum oentry)
{
translationTextTableEntryEnum entry = checkForEntry(key);
oentry = entry;
if (entry == translationTextTableEntryEnum.keyEntry)
{
return byKeys[key];
}
else if (entry == translationTextTableEntryEnum.valueEntry)
{
return byValues[key];
}
else if (entry == translationTextTableEntryEnum.unknownEntry)
{
if (isAutoConversionEnabled)
{
/*
String v = conversionMethod(key);
String k = key;
Add(k, v);
*/
SetWord(key);
return byKeys[key];
}
}
return key;
}
/// <summary>
/// Sets the entry from string pair like: <c>štetočina|stetocina</c> if <c>štetočina</c> not already defined. It will recognize automatically if its not single line but multiple lines
/// </summary>
/// <param name="entryLine">The entry line.</param>
/// <returns><see cref="translationTextTableEntryEnum.newEntry"/> if new entry was created, <see cref="translationTextTableEntryEnum.none"/> if there was problem in the format, other if the entry was found</returns>
public translationTextTableEntryEnum SetEntryFromString(string entryLine)
{
if (imbSciStringExtensions.isNullOrEmptyString(entryLine)) return translationTextTableEntryEnum.none;
if (entryLine.Contains(Environment.NewLine))
{
int c = SetEntriesFromString(entryLine);
if (c > 0) return translationTextTableEntryEnum.newEntry;
}
string[] stp = entryLine.Split(new char[] { ENTRYSEPARATOR }, StringSplitOptions.RemoveEmptyEntries);
if (stp.Count() < 2) return translationTextTableEntryEnum.none;
string k = stp[0].Trim();
string v = stp[1].Trim();
translationTextTableEntryEnum entry = checkForEntry(k);
if ((entry == translationTextTableEntryEnum.unknownEntry || entry == translationTextTableEntryEnum.valueEntry))
{
Add(k, v);
entry = translationTextTableEntryEnum.newEntry;
}
else
{
}
return entry;
}
/// <summary>
/// Sets the item into cache
/// </summary>
/// <param name="item">The item.</param>
public void Add(ILexiconItem item)
{
int retryIndex = 0;
while (retryIndex < retryLimit)
{
try
{
translationTextTableEntryEnum entry = translationTextTableEntryEnum.none;
if (item is ITermLemma)
{
ITermLemma lemma = (ITermLemma)item;
lemmas.AddUnique(item.name, lemma);
if (item.name.isNonDosChars())
{
lemmas.AddUnique(twins.GetWord(item.name, out entry), lemma);
}
foreach (TermInstance instance in lemma.instances)
{
instances.AddUnique(item.name, instance);
if (item.name.isNonDosChars())
{
instances.AddUnique(twins.GetWord(item.name, out entry), instance);
}
}
}
else if (item is ITermInstance)
{
instances.AddUnique(item.name, item as ITermInstance);
if (item.name.isNonDosChars())
{
instances.AddUnique(twins.GetWord(item.name, out entry), item as ITermInstance);
}
}
retryIndex = retryLimit + 1;
}
catch (Exception ex)
{
aceLog.log("SemanticLexiconCache->Add(" + item.name + ") failed: " + ex.Message + " Retries left[" + (retryLimit - retryIndex) + "]", null, true);
aceTerminalInput.askPressAnyKeyInTime("-- cooldown delay -- press any key to skip --", true, 3, false, 1);
retryIndex++;
}
}
}
/// <summary>
/// Gets the entry as string pair like: <c>rečnik|dictionary</c> either the <c>key</c> found as Key or Value in the table. Returns empty string if not found and autoconversion wasn't enabled
/// </summary>
/// <param name="key">The key or value to get pair for</param>
/// <returns>Gets the entry as string pair like: <c>rečnik|dictionary</c> either the <c>key</c> found as Key or Value in the table. Returns empty string if not found and autoconversion wasn't enabled</returns>
public string GetEntryAsStringPair(string key)
{
translationTextTableEntryEnum entry = checkForEntry(key);
if (entry == translationTextTableEntryEnum.keyEntry)
{
return key + ENTRYSEPARATOR + byKeys[key];
}
else if (entry == translationTextTableEntryEnum.valueEntry)
{
return byKeys[key] + ENTRYSEPARATOR + key;
}
else if (entry == translationTextTableEntryEnum.unknownEntry)
{
if (isAutoConversionEnabled)
{
return key + ENTRYSEPARATOR + conversionMethod(key);
}
}
return "";
}
/// <summary>
/// Gets the lexicon items from cached terms or failed queris
/// </summary>
/// <param name="termForm">The term form.</param>
/// <returns></returns>
public lexiconResponse getLexiconItems(string termForm, ILogBuilder loger = null)
{
lexiconResponse output = new lexiconResponse();
string termFormLat = termForm;
if (semanticLexiconManager.manager.settings.doQueryPreprocess)
{
termForm = termForm.ToLower().Trim();
// termFormLat = termForm.transliterate(transliterateFlag.cyrilicToLatin);
}
termForm = termFormLat;
output.setType(lexiconResponse.responseType.none);
if (failed.ContainsKey(termForm))
{
output = failed[termForm];
output.setType(lexiconResponse.responseType.failedQueries);
}
else if (lemmas.ContainsKey(termForm))
{
output.AddRange(lemmas[termForm]);
output.setType(lexiconResponse.responseType.cachedLexicon);
}
else if (instances.ContainsKey(termForm))
{
output.AddRange(instances[termForm]);
output.setType(lexiconResponse.responseType.cachedLexicon);
}
else
{
List <string> termForms = new List <string>();
termForms.Add(termForm);
translationTextTableEntryEnum entry = twins.checkForEntry(termForm);
switch (entry)
{
case translationTextTableEntryEnum.keyEntry:
case translationTextTableEntryEnum.valueEntry:
termForms.Add(twins.GetWord(termForm, out entry));
break;
case translationTextTableEntryEnum.unknownEntry:
if (termForm.isNonDosChars())
{
termForms.Add(twins.GetWord(termForm, out entry));
}
break;
}
if (doAllowLexiconQuery && !isLexiconPreloaded)
{
output.setType(lexiconResponse.responseType.askingLexiconContext);
output = _getLexiconItems(termForms, loger);
}
if (output.Any())
{
output.setType(lexiconResponse.responseType.lexicon);
Add(output);
}
else
{
output = AddTemp(termForms, loger);
output.setType(lexiconResponse.responseType.failedQueries);
}
}
//} catch (Exception ex)
//{
// aceGeneralException axe = new aceGeneralException("semanticLexiconCache.getLexiconItems error", ex, this, "lexCache.getLexiconItems() current state: " + output.type);
// throw axe;
//}
return(output);
}
