/// <summary>
/// Determines whether the specified term is match.
/// </summary>
/// <param name="lexItem">The lex item.</param>
/// <param name="term">The term.</param>
/// <returns>
/// <c>true</c> if the specified term is match; otherwise, <c>false</c>.
/// </returns>
public static bool IsMatch(this ILexiconItem lexItem, string term)
{
if (lexItem == null)
{
return(false);
}
return(lexItem.name == term);
}
/// <summary>
/// Gets the lexicon items.
/// </summary>
/// <param name="termForm">The term form.</param>
/// <param name="loger">The loger.</param>
/// <returns></returns>
private lexiconResponse _getLexiconItems(List <string> termForms, ILogBuilder loger = null, bool callWithAutoDiscovery = true)
{
lexiconResponse output = new lexiconResponse();
//lock (getLexiconItemsLock)
//{
output.setType(lexiconResponse.responseType.lexicon);
ILexiconItem tis_i = null;
try
{
//var tis_is = lexiconContext.TermInstances.Where(x => x.Equals(termForm)); // x=>x.name == termForm
var tis_is = lexiconContext.TermInstances.Where(x => termForms.Contains(x.name)).FirstOrDefault(); //
if (tis_is != null)
{
output.Add(tis_is);
}
}
catch (Exception ex)
{
if (loger != null)
{
loger.log("Lexicon query failed: " + termForms.toCsvInLine(",") + " (lemmas)");
}
}
if (tis_i == null)
{
try
{
var til_is = lexiconContext.TermLemmas.Where(x => termForms.Contains(x.name)).FirstOrDefault(); // var til_is = lexiconContext.TermLemmas.Where(x => x.Equals(termForm));
if (til_is != null)
{
output.Add(til_is);
}
}
catch (Exception ex)
{
if (loger != null)
{
loger.log("Lexicon query failed: " + termForms.toCsvInLine(",") + " (instances)");
}
}
}
//}
return(output);
}
public static string getItemTypeName(this ILexiconItem lexItem)
{
if (lexItem is IConcept)
{
return(nameof(semanticLexicon.Concept));
}
if (lexItem is ITermInstance)
{
return(nameof(TermInstance));
}
if (lexItem is ITermLemma)
{
return(nameof(TermLemma));
}
return("");
}
/// <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++;
}
}
}
internal void getReady(List <ILexiconItem> __items = null)
{
if (item.lexItem == null)
{
List <ILexiconItem> items = __items;
if (items == null)
{
items = semanticLexiconManager.manager.getLexiconItems(name);
}
if (items.Count() > 1)
{
item = new termSparkArm(name + "[" + items.Count() + "]", null, 1);
foreach (ILexiconItem __lexItem in items)
{
Add(new termSparkArm(__lexItem.name, __lexItem, 1));
if (lemma == null)
{
if (__lexItem is TermLemma)
{
lemma = (TermLemma)__lexItem;
}
}
}
}
else if (items.Count() == 1)
{
ILexiconItem __lexItem = items.First();
if (lemma == null)
{
if (__lexItem is TermLemma)
{
lemma = (TermLemma)__lexItem;
}
}
item = new termSparkArm(__lexItem.name, __lexItem, 1);
}
else
{
termNotFoundInLexicon = true;
// item = new termSparkArm(name, null, 1);
}
}
}
protected bool lexMatch(ILexiconItem x, string termForm)
{
if (x == null)
{
//aceLog.loger.consoleAltColorToggle();
aceLog.log("Lexicon item is null -- " + termForm);
// aceLog.loger.consoleAltColorToggle();
throw new aceGeneralException("Lexicon item is null", null, this, "lexMatch (" + termForm + ")");
return(false);
}
if (x.name == termForm)
{
return(true);
}
return(false);
}
/// <summary>
/// Gets the lexicon items.
/// </summary>
/// <param name="termForm">The term form.</param>
/// <param name="loger">The loger.</param>
/// <returns></returns>
private List <ILexiconItem> _getLexiconItems(string termForm, ILogBuilder loger = null, bool callWithAutoDiscovery = true)
{
List <ILexiconItem> output = new List <ILexiconItem>();
termForm = termForm.ToLower().Trim();
ILexiconItem tis_i = null;
try
{
//var tis_is = lexiconContext.TermInstances.Where(x => x.Equals(termForm)); // x=>x.name == termForm
var tis_is = lexiconContext.TermInstances.Where(x => x.name == termForm); //
if (tis_is != null)
{
foreach (var item in tis_is)
{
tis_i = item;
}
}
} catch (Exception ex)
{
if (loger != null)
{
loger.log("Lexicon query failed: " + termForm + " (lemmas)");
}
}
if (tis_i != null)
{
output.Add(tis_i);
}
else
{
// ITermLemma til_i = null;
try
{
var til_is = lexiconContext.TermLemmas.Where(x => x.name == termForm); // var til_is = lexiconContext.TermLemmas.Where(x => x.Equals(termForm));
if (til_is != null)
{
int c = 0;
foreach (var item in til_is)
{
output.Add(item);
c++;
if (c > 10)
{
}
}
}
} catch (Exception ex)
{
if (loger != null)
{
loger.log("Lexicon query failed: " + termForm + " (instances)");
}
}
//if (til_i != null) output.Add(til_i);
}
if (output.Any())
{
return(output);
}
if (loger == null)
{
if (settings.doResolveWordsInDebugMode)
{
loger = constructor.output;
}
}
if (callWithAutoDiscovery)
{
if (settings.doAllowLexiconSaveOnExplore)
{
output = explorer.exploreAndSave(termForm, loger, true, settings.doResolveWordsInDebugMode, termExploreItemEnumFlag.namedEntity, termExploreItemEnumFlag.aper, termExploreItemEnumFlag.srWNet, termExploreItemEnumFlag.termExplorer);
}
else
{
//output = explorer.exploreAndSave(termForm, loger, true, settings.doResolveWordsInDebugMode, termExploreItemEnumFlag.none);
}
}
return(output);
}
public termGraph(ILexiconItem __lexItem)
{
item = new termSparkArm(__lexItem.Id, __lexItem, 1);
}
/// <summary>
/// Expands the once.
/// </summary>
/// <param name="lexItem">The lex item to expand from</param>
/// <param name="type">The type of expansion</param>
/// <param name="exclude">Items not to expand to</param>
/// <returns></returns>
public static List <ILexiconItem> expandOnce(this ILexiconItem lexItem, lexiconItemExpandEnum type = lexiconItemExpandEnum.upBelowLateral, List <ILexiconItem> exclude = null)
{
string itemType = lexItem.getItemTypeName();
List <ILexiconItem> output = new List <ILexiconItem>();
if (exclude == null)
{
exclude = new List <ILexiconItem>();
}
if (type.HasFlag(lexiconItemExpandEnum.includeStart))
{
output.Add(lexItem);
}
switch (itemType)
{
case nameof(semanticLexicon.Concept):
IConcept concept = lexItem as IConcept;
if (type.HasFlag(lexiconItemExpandEnum.below))
{
output.AddRange(concept.lemmas);
output.AddRange(concept.hypoConcepts);
}
if (type.HasFlag(lexiconItemExpandEnum.lateral))
{
output.AddRange(concept.relatedTo);
output.AddRange(concept.relatedFrom, true);
}
if (type.HasFlag(lexiconItemExpandEnum.conceptUp))
{
output.AddUnique(concept.hyperConcept);
}
break;
case nameof(TermLemma):
ITermLemma lemma = lexItem as ITermLemma;
if (lemma == null)
{
return(output);
}
if (type.HasFlag(lexiconItemExpandEnum.below))
{
if (lemma.instances != null)
{
output.AddRange(lemma.instances);
}
}
if (type.HasFlag(lexiconItemExpandEnum.lateral))
{
if (lemma.relatedFrom != null)
{
output.AddRange(lemma.relatedFrom);
}
if (lemma.relatedTo != null)
{
output.AddRange(lemma.relatedTo);
}
}
if (type.HasFlag(lexiconItemExpandEnum.up))
{
if (lemma.concepts != null)
{
output.AddRange(lemma.concepts);
}
}
if (type.HasFlag(lexiconItemExpandEnum.compounds))
{
if (lemma.compounds != null)
{
output.AddRange(lemma.compounds);
}
}
break;
case nameof(TermInstance):
ITermInstance instance = lexItem as ITermInstance;
if (type.HasFlag(lexiconItemExpandEnum.up))
{
output.AddUnique(instance.lemma);
}
break;
}
output.RemoveAll(x => exclude.Contains(x));
return(output);
}
public termSparkArm(string __name, ILexiconItem __lexItem, double __weight)
{
lexItem = __lexItem;
name = __name;
weight = __weight;
}
