/// <summary>
/// Adds the term model to the lexicon
/// </summary>
/// <param name="termModel">The term model.</param>
public void addTermModelToLexicon(termExploreModel termModel)
{
//var tlt = manager.lexiconContext.TermLemmas.Where<ITermLemma>(x => x.name.Equals(termModel.lemma.inputForm)&& x.type.Equals(termModel.lemma.gramSet.getPosType().toString()));
ITermLemma tl = manager.lexiconContext.TermLemmas.Where(x => x.name.Equals(termModel.lemmaForm)).FirstOrDefault();
//IQueryable<ITermLemma> tlt = manager.lexiconContext.TermLemmas.Where(x => x.name.Equals(termModel.lemma.inputForm));
//List<ITermLemma> tlt_l = tlt.ToList();
//ITermLemma tl = null;
if (tl != null)
{
// nista nije uradjeno
}
else
{
tl = manager.lexiconContext.TermLemmas.Create();
tl.name = termModel.lemmaForm.or(termModel.inputForm);
tl.gramSet = termModel.getGramSet();
tl.type = termModel.getPosType().toStringSafe("TEMP");
//if (termModel tl.type = termModel.gramSet.getPosType().toString();
foreach (termExploreItem item in termModel.instances)
{
ITermInstance ti = manager.lexiconContext.TermInstances.Where(x => x.name.Equals(item.inputForm)).FirstOrDefault();
if (ti == null)
{
ti = manager.lexiconContext.TermInstances.Create();
ti.name = item.inputForm;
//
ti.gramSet = item.getGramSet(); //.gramSet.GetAll();
ti.type = item.getPosType().toStringSafe(); //.// .gramSet.getPosType().toString();
ti.lemma = tl;
}
else
{
if (manager.settings.doResolveWordsInDebugMode)
{
output.AppendLine("Item [" + item.inputForm + "] of lemma [" + tl.name + "] was already defined.");
//foreach (var lm in ti.)
// output.AppendLine("[" + item.inputForm + "]->lemma [" + tl.name + "] was already defined.");
}
}
manager.lexiconContext.TermInstances.Add(ti);
}
}
manager.lexiconContext.SaveChanges();
}
/// <summary>
/// Initializes a new instance of the <see cref="termExploreModel"/> class.
/// </summary>
/// <param name="lemmaSource">The lemma source.</param>
public termExploreModel(ITermLemma lemmaSource)
{
inputForm = lemmaSource.name;
modelSource = termExploreModelSource.fromLemma;
lemma = new termExploreItem(lemmaSource.name, lemmaSource.gramSet);
foreach (TermInstance ins in lemmaSource.instances)
{
instances.Add(new termExploreItem(ins.name, ins.gramSet));
}
}
/// <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 model from the Lexicon lemma entry -- loads from file, or if file do not exist - reconstructs it from the TermLema
/// </summary>
/// <param name="lemma">The lemma.</param>
/// <returns></returns>
public termExploreModel getTermModel(ITermLemma lemma, bool dontLoadFromFile = false)
{
termExploreModel output = new termExploreModel();
if (!dontLoadFromFile)
{
string filepath = projectFolderStructure[lexiconConstructorProjectFolder.metadata].pathFor(lemma.name + "_" + lemma.type.ToString() + ".xml");
if (File.Exists(filepath))
{
output = objectSerialization.loadObjectFromXML <termExploreModel>(filepath);
output.modelSource = termExploreModelSource.fromFile;
return(output);
}
}
output = new termExploreModel(lemma);
return(output);
}
public static List <TermLemma> getAllRelated(this ITermLemma lemma)
{
List <TermLemma> re_synonyms = new List <TermLemma>();
foreach (TermLemma rel in lemma.relatedTo)
{
if (!re_synonyms.Any(x => x.name == rel.name))
{
re_synonyms.Add(rel);
}
}
foreach (TermLemma rel in lemma.relatedFrom)
{
if (!re_synonyms.Any(x => x.name == rel.name))
{
re_synonyms.Add(rel);
}
}
return(re_synonyms);
}
/// <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 TempInstance(string __name, ITermLemma __lemma)
{
Id = md5.GetMd5Hash(__name);
lemma = __lemma;
name = __name;
}
