private void SearchInAbbreviationForMatches(ICmSemanticDomain domain) { if (domain.Abbreviation.BestAnalysisAlternative.Text.StartsWith(m_searchString)) { SearchResults.AddResultToBucketX(0, domain); } }
private void SetRelatedDomainsLinks() { ICmSemanticDomainRepository repo = m_cache.ServiceLocator.GetInstance <ICmSemanticDomainRepository>(); foreach (Guid guidKey in m_mapRelatedDomains.Keys) { try { ICmSemanticDomain dom = repo.GetObject(guidKey); foreach (Guid guidLink in m_mapRelatedDomains[guidKey]) { try { ICmSemanticDomain domLink = repo.GetObject(guidLink); dom.RelatedDomainsRC.Add(domLink); } catch { } } if (m_progress != null) { m_progress.Step(1); } } catch { } } }
/// <summary> /// Get the text from a Semantic Domain's Name field. /// </summary> /// <param name="domain"></param> /// <returns>an array of Tuples, where each Tuple has a ws handle and a name string</returns> private static Tuple <int, string>[] GetDomainNameString(ICmSemanticDomain domain) { var name = domain.Name; return(name.AvailableWritingSystemIds.Select(ws => new Tuple <int, string>( ws, name.get_String(ws).Text)).Where(tuple => !String.IsNullOrEmpty(tuple.Item2)).ToArray()); }
/// <summary> /// Take a string to look in (from a domain's Name or ExampleWords) and try to find /// a match for some (strategy-defined) search key(s). /// </summary> /// <param name="searchIn"></param> /// <param name="domain"></param> /// <param name="wholeWordBucket"></param> /// <returns></returns> protected bool CollectPossibleMatchIn(string searchIn, ICmSemanticDomain domain, int wholeWordBucket) { if (string.IsNullOrEmpty(searchIn)) { return(false); } var wordsToLookIn = ParseStringIntoWords(searchIn); switch (DoesInputMatchWord(wordsToLookIn)) { case MatchingResult.WholeWordMatch: SearchResults.AddResultToBucketX(wholeWordBucket, domain); return(true); case MatchingResult.StartOfWordMatch: SearchResults.AddResultToBucketX(wholeWordBucket + PartialMatchRelativeIndex, domain); return(true); case MatchingResult.NoMatch: // do nothing break; default: throw new ApplicationException("Unknown MatchingResult"); } return(false); }
protected override void PopulatePossibilityFromExtraData(ICmPossibility poss) { ICmSemanticDomain semdom = poss as ICmSemanticDomain; if (semdom == null) { return; } ILgWritingSystemFactory wsf = semdom.Cache.WritingSystemFactory; var questionFactory = semdom.Cache.ServiceLocator.GetInstance <ICmDomainQFactory>(); Dictionary <string, List <SemDomQuestion> > questionsByWs = GetExtraDataWsDict <SemDomQuestion>("Questions"); // This dict looks like {"en": (question 1, question 2...)} but each question object wants to get data that // looks more or less like {"en": "the question in English", "fr": "la question en francais"}... // So first we ensure that there are enough question objects available, and then we'll access them by index // as we step through the writing systems. int numQuestions = questionsByWs.Values.Select(questionList => questionList.Count).Max(); while (semdom.QuestionsOS.Count < numQuestions) { semdom.QuestionsOS.Add(questionFactory.Create()); } foreach (string ws in questionsByWs.Keys) { int wsId = wsf.GetWsFromStr(ws); int i = 0; foreach (SemDomQuestion qStruct in questionsByWs[ws]) { semdom.QuestionsOS[i].Question.set_String(wsId, qStruct.Question ?? string.Empty); semdom.QuestionsOS[i].ExampleSentences.set_String(wsId, qStruct.ExampleSentences ?? string.Empty); semdom.QuestionsOS[i].ExampleWords.set_String(wsId, qStruct.ExampleWords ?? string.Empty); i++; } } }
/// <summary> /// The buckets are ordered in priority so adding a result to one bucket /// should remove that result from all lower (higher index) ones. /// N.B. Strategy subclasses should take care not to add a domain to a bucket /// if it is already in a higher priority bucket. /// </summary> /// <param name="bucketIndex"></param> /// <param name="domain"></param> public void AddResultToBucketX(int bucketIndex, ICmSemanticDomain domain) { m_bucketList[bucketIndex].Add(domain); for (var i = bucketIndex + 1; i < m_bucketList.Length; i++) { m_bucketList[i].Remove(domain); } }
/// <summary> /// Subclasses can override this method to change how Semantic Domains are compared /// with any search key(s) and the priority types of matches for putting the /// domain into an appropriate search results bucket (if any). /// N.B. Strategy subclasses should take care not to add a domain to a bucket /// if it is already in a higher priority bucket. /// </summary> /// <param name="domain"></param> internal virtual void PutDomainInDesiredBucket(ICmSemanticDomain domain) { // Check for whole word and partial matches in Name first if (!CollectPossibleMatchIn(GetDomainNameString(domain), domain, WholeWordBucketIndex)) { // If no whole word match in Name, look in Example Words too. CollectPossibleMatchIn(GetExampleWordsString(domain.QuestionsOS), domain, WholeWordExamplesBucketIndex); } }
internal override void PutDomainInDesiredBucket(ICmSemanticDomain domain) { foreach (var kvp in m_searchKeys) { CurrentWs = kvp.Key; CurrentSearchKeys = kvp.Value; base.PutDomainInDesiredBucket(domain); } }
private void CacheWordsIn(Tuple<int, string>[] wsStringTupleArray, ICmSemanticDomain domain) { foreach (var tuple in wsStringTupleArray) { var ws = tuple.Item1; var words = ParseStringIntoWords(tuple.Item2); foreach (var word in words) { CacheWord(ws, word, domain); } } }
private void CacheWordsIn(Tuple <int, string>[] wsStringTupleArray, ICmSemanticDomain domain) { foreach (var tuple in wsStringTupleArray) { var ws = tuple.Item1; var words = ParseStringIntoWords(tuple.Item2); foreach (var word in words) { CacheWord(ws, word, domain); } } }
/// <summary> /// Don't count references to Semantic Domains from other Semantic Domains. /// The user only cares about how many times in the lexicon the Semantic Domain is used. /// </summary> /// <param name="domain"></param> /// <returns></returns> public static int SenseReferenceCount(ICmSemanticDomain domain) { int count = 0; if (domain.ReferringObjects != null) { count = (from item in domain.ReferringObjects where item is ILexSense select item).Count(); } return(count); }
/// <summary> /// Load data that looks like this /// <Questions> /// <CmDomainQ> /// <Question> /// <AUni ws="en">(1) What words refer to the sun?</AUni> /// <AUni ws="fr">Quels sont les mots pour parler du soleil?</AUni> /// </Question> /// <ExampleWords> /// <AUni ws="en">sun, solar, sol, daystar, our star</AUni> /// <AUni ws="fr">soleil, solaire, notre soleil</AUni> /// </ExampleWords> /// </CmDomainQ> /// <CmDomainQ> /// <Question> /// <AUni ws="en">(2) What words refer to the time when the sun rises?</AUni> /// <AUni ws="fr">Quels sont les mots qui signifient le lever du soleil?</AUni> /// </Question> /// <ExampleWords> /// <AUni ws="en">dawn, sunrise, sunup, daybreak, cockcrow, </AUni> /// </ExampleWords> /// <ExampleSentences> /// <AStr ws="en"> /// <Run ws="en">We got up before dawn, in order to get an early start.</Run> /// </AStr> /// </ExampleSentences> /// </CmDomainQ> ///</Questions> /// </summary> private void LoadQuestionsFromXml(XmlReader xrdr, ICmSemanticDomain dom) { Debug.Assert(dom != null); if (xrdr.ReadToDescendant("CmDomainQ")) { EnsureFactoryForClass("CmDomainQ"); do { ReadDomainQuestion(xrdr.ReadSubtree(), dom); } while (xrdr.ReadToNextSibling("CmDomainQ")); } xrdr.Read(); // reads end element }
private void ReadDomainQuestion(XmlReader xrdrSub, ICmSemanticDomain dom) { try { ICmDomainQ domQ = null; while (xrdrSub.Read()) { if (xrdrSub.NodeType == XmlNodeType.Element) { switch (xrdrSub.Name) { case "ExampleSentences": if (domQ == null) { domQ = m_factCmDomainQ.Create(); dom.QuestionsOS.Add(domQ); } SetMultiStringFromXml(xrdrSub, domQ.ExampleSentences); break; case "ExampleWords": if (domQ == null) { domQ = m_factCmDomainQ.Create(); dom.QuestionsOS.Add(domQ); } SetMultiUnicodeFromXml(xrdrSub, domQ.ExampleWords); break; case "Question": if (domQ == null) { domQ = m_factCmDomainQ.Create(); dom.QuestionsOS.Add(domQ); } SetMultiUnicodeFromXml(xrdrSub, domQ.Question); break; } } } } finally { xrdrSub.Close(); } }
private void CacheWord(int ws, string word, ICmSemanticDomain domain) { var searchKey = new Tuple<string, int>(word, ws); HashSet<ICmSemanticDomain> cachedValues; // out var if (m_semDomCache.TryGetValue(searchKey, out cachedValues)) { if (cachedValues.Contains(domain)) return; // this domain is already cached // searchKey is already cached, but we need to add this domain cachedValues.Add(domain); m_semDomCache.Remove(searchKey); m_semDomCache.Add(searchKey, cachedValues); return; } // searchKey was not found, add it with this domain m_semDomCache.Add(searchKey, new HashSet<ICmSemanticDomain>() { domain }); }
/// <summary> /// This implementation checks to see of the search key starts with a digit first. /// If so, it looks in the Abbreviation field for a search key match in the hierarchical number /// (e.g. "8.3.3"; these would go in the first bucket). /// Otherwise it checks next for matches where the key corresponds to the beginning /// of the Name field (first bucket). Failing that, it checks for whole word (second bucket) or /// partial matches (third bucket) between the search key and the contents of a Semantic Domain's /// Name and ExampleWords fields. /// N.B. Strategy subclasses should take care not to add a domain to a bucket /// if it is already in a higher priority bucket. /// </summary> internal override void PutDomainInDesiredBucket(ICmSemanticDomain domain) { // Look in Name and Example Words for matches if (m_fnumeric) { SearchInAbbreviationForMatches(domain); return; } // Check to see if this domain is a first bucket match // Boolean param in StartsWith() ignores case // N.B.: WritingSystem check should be the same as what's displayed in the UI! if (domain.Name.BestAnalysisAlternative.Text.StartsWith(m_searchString, true, AppropriateCulture)) { SearchResults.AddResultToBucketX(0, domain); return; } base.PutDomainInDesiredBucket(domain); }
private ILexEntry MakeLexEntry(string cf, string defn, ICmSemanticDomain domain) { var servLoc = Cache.ServiceLocator; var le = servLoc.GetInstance <ILexEntryFactory>().Create(); var ws = Cache.DefaultVernWs; le.CitationForm.set_String(ws, Cache.TsStrFactory.MakeString(cf, ws)); var ls = servLoc.GetInstance <ILexSenseFactory>().Create(); le.SensesOS.Add(ls); ws = Cache.DefaultAnalWs; ls.Definition.set_String(ws, Cache.TsStrFactory.MakeString(defn, ws)); ls.SemanticDomainsRC.Add(domain); var msa = servLoc.GetInstance <IMoStemMsaFactory>().Create(); le.MorphoSyntaxAnalysesOC.Add(msa); ls.MorphoSyntaxAnalysisRA = msa; return(le); }
private void ReadQuestionsFromXml(XmlReader xrdrSub, ICmSemanticDomain semdom) { try { if (xrdrSub.IsEmptyElement) { xrdrSub.Read(); } else if (xrdrSub.ReadToDescendant("CmDomainQ")) { do { ReadDomainQFromXml(xrdrSub.ReadSubtree(), semdom); } while (xrdrSub.ReadToNextSibling("CmDomainQ")); } } finally { xrdrSub.Close(); } }
/// <summary> /// Load data that looks like this, storing it for future processing. (Some of the /// guids may be forward references.) /// <RelatedDomains> /// <Link guid="4BF411B7-2B5B-4673-B116-0E6C31FBD08A"/> /// <Link guid="CBA6876C-5B48-42F4-AE0A-7FBE9BB971EF"/> /// <Link guid="0CC62B4A-D5FF-4F45-83D1-E2B46E5D159A"/> /// </RelatedDomains> /// </summary> private void LoadRelatedDomainsFromXml(XmlReader xrdr, ICmSemanticDomain dom) { Debug.Assert(dom != null); if (xrdr.ReadToDescendant("Link")) { do { string sGuid = xrdr.GetAttribute("guid"); if (!String.IsNullOrEmpty(sGuid)) { Guid guidLink = new Guid(sGuid); List <Guid> rgGuids; if (!m_mapRelatedDomains.TryGetValue(dom.Guid, out rgGuids)) { rgGuids = new List <Guid>(); m_mapRelatedDomains.Add(dom.Guid, rgGuids); } rgGuids.Add(guidLink); } } while (xrdr.ReadToNextSibling("Link")); } xrdr.Read(); // reads end element }
private void CacheWord(int ws, string word, ICmSemanticDomain domain) { var searchKey = new Tuple <string, int>(word, ws); HashSet <ICmSemanticDomain> cachedValues; // out var if (m_semDomCache.TryGetValue(searchKey, out cachedValues)) { if (cachedValues.Contains(domain)) { return; // this domain is already cached } // searchKey is already cached, but we need to add this domain cachedValues.Add(domain); m_semDomCache.Remove(searchKey); m_semDomCache.Add(searchKey, cachedValues); return; } // searchKey was not found, add it with this domain m_semDomCache.Add(searchKey, new HashSet <ICmSemanticDomain>() { domain }); }
/// <summary> /// This implementation checks to see of the search key starts with a digit first. /// If so, it looks in the Abbreviation field for a search key match in the hierarchical number /// (e.g. "8.3.3"; these would go in the first bucket). /// Otherwise it checks next for matches where the key corresponds to the beginning /// of the Name field (first bucket). Failing that, it checks for whole word (second bucket) or /// partial matches (third bucket) between the search key and the contents of a Semantic Domain's /// Name and ExampleWords fields. /// N.B. Strategy subclasses should take care not to add a domain to a bucket /// if it is already in a higher priority bucket. /// </summary> internal override void PutDomainInDesiredBucket(ICmSemanticDomain domain) { // Look in Name and Example Words for matches if (m_fnumeric) { SearchInAbbreviationForMatches(domain); return; } // Check to see if this domain is an exact match // Boolean param in Compare() ignores case // N.B.: WritingSystem check should be the same as what's displayed in the UI! if (String.Compare(domain.Name.BestAnalysisAlternative.Text, m_searchString, true, AppropriateCulture) == 0) { SearchResults.AddResultToBucketX(0, domain); return; } base.PutDomainInDesiredBucket(domain); }
/// <summary> /// Load data that looks like this, storing it for future processing. (Some of the /// guids may be forward references.) /// <RelatedDomains> /// <Link guid="4BF411B7-2B5B-4673-B116-0E6C31FBD08A"/> /// <Link guid="CBA6876C-5B48-42F4-AE0A-7FBE9BB971EF"/> /// <Link guid="0CC62B4A-D5FF-4F45-83D1-E2B46E5D159A"/> /// </RelatedDomains> /// </summary> private void LoadRelatedDomainsFromXml(XmlReader xrdr, ICmSemanticDomain dom) { Debug.Assert(dom != null); if (xrdr.ReadToDescendant("Link")) { do { string sGuid = xrdr.GetAttribute("guid"); if (!String.IsNullOrEmpty(sGuid)) { Guid guidLink = new Guid(sGuid); List<Guid> rgGuids; if (!m_mapRelatedDomains.TryGetValue(dom.Guid, out rgGuids)) { rgGuids = new List<Guid>(); m_mapRelatedDomains.Add(dom.Guid, rgGuids); } rgGuids.Add(guidLink); } } while (xrdr.ReadToNextSibling("Link")); } xrdr.Read(); // reads end element }
/// <summary> /// Load data that looks like this /// <Questions> /// <CmDomainQ> /// <Question> /// <AUni ws="en">(1) What words refer to the sun?</AUni> /// <AUni ws="fr">Quels sont les mots pour parler du soleil?</AUni> /// </Question> /// <ExampleWords> /// <AUni ws="en">sun, solar, sol, daystar, our star</AUni> /// <AUni ws="fr">soleil, solaire, notre soleil</AUni> /// </ExampleWords> /// </CmDomainQ> /// <CmDomainQ> /// <Question> /// <AUni ws="en">(2) What words refer to the time when the sun rises?</AUni> /// <AUni ws="fr">Quels sont les mots qui signifient le lever du soleil?</AUni> /// </Question> /// <ExampleWords> /// <AUni ws="en">dawn, sunrise, sunup, daybreak, cockcrow, </AUni> /// </ExampleWords> /// <ExampleSentences> /// <AStr ws="en"> /// <Run ws="en">We got up before dawn, in order to get an early start.</Run> /// </AStr> /// </ExampleSentences> /// </CmDomainQ> ///</Questions> /// </summary> private void LoadQuestionsFromXml(XmlReader xrdr, ICmSemanticDomain dom) { Debug.Assert(dom != null); if (xrdr.ReadToDescendant("CmDomainQ")) { EnsureFactoryForClass("CmDomainQ"); do { ReadDomainQuestion(xrdr.ReadSubtree(), dom); } while (xrdr.ReadToNextSibling("CmDomainQ")); } xrdr.Read(); // reads end element }
/// <summary> /// Get the text from a Semantic Domain's Name field. /// This version uses BestAnalysisAlternative which should always have a value, /// but a subclass might use a more specific writing system which may not have a value /// (i.e. be prepared for a null return value). /// </summary> /// <param name="domain"></param> /// <returns></returns> protected virtual string GetDomainNameString(ICmSemanticDomain domain) { return(domain.Name.BestAnalysisAlternative.Text); }
/// <summary> /// Subclasses can override this method to change how Semantic Domains are compared /// with any search key(s) and the priority types of matches for putting the /// domain into an appropriate search results bucket (if any). /// N.B. Strategy subclasses should take care not to add a domain to a bucket /// if it is already in a higher priority bucket. /// </summary> /// <param name="domain"></param> internal virtual void PutDomainInDesiredBucket(ICmSemanticDomain domain) { // Check for whole word and partial matches in Name first if (!CollectPossibleMatchIn(GetDomainNameString(domain), domain, WholeWordBucketIndex)) { // If no whole word match in Name, look in Example Words too. CollectPossibleMatchIn(GetExampleWordsString(domain.QuestionsOS), domain, WholeWordExamplesBucketIndex); } }
/// <summary> /// Get the text from a Semantic Domain's Name field. /// This version uses BestAnalysisAlternative which should always have a value, /// but a subclass might use a more specific writing system which may not have a value /// (i.e. be prepared for a null return value). /// </summary> /// <param name="domain"></param> /// <returns></returns> protected virtual string GetDomainNameString(ICmSemanticDomain domain) { return domain.Name.BestAnalysisAlternative.Text; }
private ILexEntry MakeLexEntry(string cf, string defn, ICmSemanticDomain domain) { var servLoc = Cache.ServiceLocator; var le = servLoc.GetInstance<ILexEntryFactory>().Create(); var ws = Cache.DefaultVernWs; le.CitationForm.set_String(ws, Cache.TsStrFactory.MakeString(cf, ws)); var ls = servLoc.GetInstance<ILexSenseFactory>().Create(); le.SensesOS.Add(ls); ws = Cache.DefaultAnalWs; ls.Definition.set_String(ws, Cache.TsStrFactory.MakeString(defn, ws)); ls.SemanticDomainsRC.Add(domain); var msa = servLoc.GetInstance<IMoStemMsaFactory>().Create(); le.MorphoSyntaxAnalysesOC.Add(msa); ls.MorphoSyntaxAnalysisRA = msa; return le; }
public override void FixtureSetup() { base.FixtureSetup(); m_entryFactory = Cache.ServiceLocator.GetInstance <ILexEntryFactory>(); m_senseFactory = Cache.ServiceLocator.GetInstance <ILexSenseFactory>(); m_exampleFactory = Cache.ServiceLocator.GetInstance <ILexExampleSentenceFactory>(); m_lexEntryRefFactory = Cache.ServiceLocator.GetInstance <ILexEntryRefFactory>(); m_lexRefTypeFactory = Cache.ServiceLocator.GetInstance <ILexRefTypeFactory>(); m_lexRefFactory = Cache.ServiceLocator.GetInstance <ILexReferenceFactory>(); m_possListFactory = Cache.ServiceLocator.GetInstance <ICmPossibilityListFactory>(); m_flidReferringSenses = Cache.MetaDataCacheAccessor.GetFieldId2(CmSemanticDomainTags.kClassId, "ReferringSenses", false); UndoableUnitOfWorkHelper.Do("do", "undo", Cache.ActionHandlerAccessor, () => { m_domainBadWords = Cache.ServiceLocator.GetInstance <ICmSemanticDomainFactory>().Create(); m_domainTemperature = Cache.ServiceLocator.GetInstance <ICmSemanticDomainFactory>().Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainBadWords); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainTemperature); m_mainDict = Cache.LangProject.LexDbOA.PublicationTypesOA.PossibilitiesOS[0]; m_blank = MakeEntry("blank", "swear word", true); m_blank.SensesOS[0].SemanticDomainsRC.Add(m_domainBadWords); m_hot = MakeEntry("hot", "high temperature", false); m_hotTemp = m_hot.SensesOS[0]; m_hotTemp.SemanticDomainsRC.Add(m_domainTemperature); m_trouble = MakeSense(m_hot, "trouble"); m_trouble.DoNotPublishInRC.Add(m_mainDict); m_trouble.PicturesOS.Add(Cache.ServiceLocator.GetInstance <ICmPictureFactory>().Create()); m_desirable = MakeSense(m_hot, "desirable"); m_fastCar = MakeSense(m_desirable, "fast (car)"); m_badHot = MakeExample(m_hotTemp, "a hot pile of blank", true); m_goodHot = MakeExample(m_hotTemp, "a hot bath", false); m_water = MakeEntry("water", "H2O", false); m_waterH2O = m_water.SensesOS[0]; m_hotWater = MakeEntry("hot water", "trouble", false); m_hotWaterComponents = MakeEntryRef(m_hotWater, new ICmObject[] { m_trouble, m_waterH2O }, new[] { m_trouble, m_waterH2O }, LexEntryRefTags.krtComplexForm); m_blank2 = MakeEntry("blank", "vacant", false); m_blank3 = MakeEntry("blank", "erase", false); m_water2 = MakeEntry("water", "urinate", true); m_waterPrefix = MakeEntry("water", "aquatic", false); m_waterPrefix.LexemeFormOA.MorphTypeRA = Cache.ServiceLocator.GetInstance <IMoMorphTypeRepository>() .GetObject(MoMorphTypeTags.kguidMorphPrefix); m_synonym = MakeRefType("synonym", null, (int)LexRefTypeTags.MappingTypes.kmtSenseCollection); m_blip = MakeEntry("blip", "rude word", true); m_bother = MakeEntry("bother", "I'm annoyed by that", false); m_ouch = MakeEntry("ouch", "that hurt", false); m_blipOuch = MakeSense(m_blip.SensesOS[0], "rude ouch"); m_blankSynonyms = MakeLexRef(m_synonym, new ICmObject[] { m_blank, m_ouch.SensesOS[0], m_blip.SensesOS[0], m_blipOuch, m_bother }); m_problem = MakeEntry("problem", "difficulty", false); m_problemSynonyms = MakeLexRef(m_synonym, new ICmObject[] { m_problem, m_trouble }); m_body = MakeEntry("body", "body", true); m_arm = MakeEntry("arm", "arm", false); m_leg = MakeEntry("leg", "leg", false); m_belly = MakeEntry("belly", "belly", true); m_torso = MakeEntry("torso", "torso", false); m_partWhole = MakeRefType("partWhole", null, (int)LexRefTypeTags.MappingTypes.kmtEntryTree); m_bodyParts = MakeLexRef(m_partWhole, new ICmObject[] { m_body, m_arm, m_leg.SensesOS[0], m_torso, m_belly }); m_torsoParts = MakeLexRef(m_partWhole, new ICmObject[] { m_torso, m_arm, m_belly }); m_hotBlank = MakeEntry("hotBlank", "problem rude word", false); MakeEntryRef(m_hotBlank, new ICmObject[] { m_trouble, m_water2 }, new ICmObject[] { m_trouble, m_water2 }, LexEntryRefTags.krtComplexForm); m_blueColor = MakeEntry("blue", "color blue", false); m_blueCold = MakeEntry("blue", "cold", false); m_blueMusic = MakeEntry("blue", "jazzy", false); m_blueSad = MakeEntry("blue", "sad", false); m_blueMusic.HomographNumber = 2; // will duplicate blue cold; pathological, but should not crash. m_blueSad.HomographNumber = 3; // will conflict with renumbered blueMusic m_bluer = m_blueColor.SensesOS[0]; m_sky = MakeEntry("sky", "interface between atmosphere and space", false, true); // true excludes as headword m_skyReal = m_sky.SensesOS[0]; m_blueSky = MakeEntry("blue sky", "clear, huge potential", false, false); m_blueSkyComponents = MakeEntryRef(m_blueSky, new ICmObject[] { m_blueColor, m_skyReal }, new[] { m_bluer, m_skyReal }, LexEntryRefTags.krtComplexForm); m_ringBell = MakeEntry("ring", "bell", false, false); m_ringCircle = MakeEntry("ring", "circle", false, true); m_ringGold = MakeEntry("ring", "gold", false, false); m_blackVerb = MakeEntry("black", "darken", false, true); m_blackColor = MakeEntry("black", "dark", false, false); m_hotArm = MakeEntry("hotarm", "pitcher", false, false); m_hotArmComponents = MakeEntryRef(m_hotArm, new ICmObject[] { m_hot, m_arm }, new[] { m_hot, m_arm }, LexEntryRefTags.krtComplexForm); m_hotArm.DoNotPublishInRC.Add(m_mainDict); m_hotArmComponents.ShowComplexFormsInRS.Add(m_hot); m_nolanryan = MakeEntry("Nolan_Ryan", "pitcher", false, false); m_nolanryanComponents = MakeEntryRef(m_nolanryan, new ICmObject[] { m_hot }, new[] { m_hot }, LexEntryRefTags.krtVariant); m_nolanryanComponents.VariantEntryTypesRS.Add( (ILexEntryType)Cache.LangProject.LexDbOA.VariantEntryTypesOA.PossibilitiesOS[0]); m_nolanryan.DoNotPublishInRC.Add(m_mainDict); m_publisher = new MockPublisher((ISilDataAccessManaged)Cache.DomainDataByFlid, kmainFlid); m_publisher.SetOwningPropValue(Cache.LangProject.LexDbOA.Entries.Select(le => le.Hvo).ToArray()); m_decorator = new DictionaryPublicationDecorator(Cache, m_publisher, ObjectListPublisher.OwningFlid); }); }
private void ExportSemanticDomainFields(TextWriter w, TextWriterStream stream, ICmSemanticDomain item) { if (item != null && item.QuestionsOS.Count > 0) { w.WriteLine("<Questions>"); foreach (var domainQ in item.QuestionsOS) { w.WriteLine("<CmDomainQ>"); ExportMultiUnicode(w, domainQ.Question); ExportMultiUnicode(w, domainQ.ExampleWords); ExportMultiString(w, stream, domainQ.ExampleSentences); w.WriteLine("</CmDomainQ>"); } w.WriteLine("</Questions>"); } }
internal override void PutDomainInDesiredBucket(ICmSemanticDomain domain) { foreach (var kvp in m_searchKeys) { CurrentWs = kvp.Key; CurrentSearchKeys = kvp.Value; base.PutDomainInDesiredBucket(domain); } }
/// <summary> /// Get the text from a Semantic Domain's Name field. /// This version uses AnalysisDefault ws which may not always have a value /// (i.e. be prepared for a null return value). /// </summary> /// <param name="domain"></param> /// <returns></returns> protected override string GetDomainNameString(ICmSemanticDomain domain) { return domain.Name.get_String(CurrentWs).Text; }
public override void FixtureSetup() { base.FixtureSetup(); m_entryFactory = Cache.ServiceLocator.GetInstance<ILexEntryFactory>(); m_senseFactory = Cache.ServiceLocator.GetInstance<ILexSenseFactory>(); m_exampleFactory = Cache.ServiceLocator.GetInstance<ILexExampleSentenceFactory>(); m_lexEntryRefFactory = Cache.ServiceLocator.GetInstance<ILexEntryRefFactory>(); m_lexRefTypeFactory = Cache.ServiceLocator.GetInstance<ILexRefTypeFactory>(); m_lexRefFactory = Cache.ServiceLocator.GetInstance<ILexReferenceFactory>(); m_possListFactory = Cache.ServiceLocator.GetInstance<ICmPossibilityListFactory>(); m_flidReferringSenses = Cache.MetaDataCacheAccessor.GetFieldId2(CmSemanticDomainTags.kClassId, "ReferringSenses", false); UndoableUnitOfWorkHelper.Do("do", "undo", Cache.ActionHandlerAccessor, () => { m_domainBadWords = Cache.ServiceLocator.GetInstance<ICmSemanticDomainFactory>().Create(); m_domainTemperature = Cache.ServiceLocator.GetInstance<ICmSemanticDomainFactory>().Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainBadWords); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainTemperature); m_mainDict = Cache.LangProject.LexDbOA.PublicationTypesOA.PossibilitiesOS[0]; m_blank = MakeEntry("blank", "swear word", true); m_blank.SensesOS[0].SemanticDomainsRC.Add(m_domainBadWords); m_hot = MakeEntry("hot", "high temperature", false); m_hotTemp = m_hot.SensesOS[0]; m_hotTemp.SemanticDomainsRC.Add(m_domainTemperature); m_trouble = MakeSense(m_hot, "trouble"); m_trouble.DoNotPublishInRC.Add(m_mainDict); m_trouble.PicturesOS.Add(Cache.ServiceLocator.GetInstance<ICmPictureFactory>().Create()); m_desirable = MakeSense(m_hot, "desirable"); m_fastCar = MakeSense(m_desirable, "fast (car)"); m_badHot = MakeExample(m_hotTemp, "a hot pile of blank", true); m_goodHot = MakeExample(m_hotTemp, "a hot bath", false); m_water = MakeEntry("water", "H2O", false); m_waterH2O = m_water.SensesOS[0]; m_hotWater = MakeEntry("hot water", "trouble", false); m_hotWaterComponents = MakeEntryRef(m_hotWater, new ICmObject[] { m_trouble, m_waterH2O }, new[] { m_trouble, m_waterH2O }, LexEntryRefTags.krtComplexForm); m_blank2 = MakeEntry("blank", "vacant", false); m_blank3 = MakeEntry("blank", "erase", false); m_water2 = MakeEntry("water", "urinate", true); m_waterPrefix = MakeEntry("water", "aquatic", false); m_waterPrefix.LexemeFormOA.MorphTypeRA = Cache.ServiceLocator.GetInstance<IMoMorphTypeRepository>() .GetObject(MoMorphTypeTags.kguidMorphPrefix); m_synonym = MakeRefType("synonym", null, (int)LexRefTypeTags.MappingTypes.kmtSenseCollection); m_blip = MakeEntry("blip", "rude word", true); m_bother = MakeEntry("bother", "I'm annoyed by that", false); m_ouch = MakeEntry("ouch", "that hurt", false); m_blipOuch = MakeSense(m_blip.SensesOS[0], "rude ouch"); m_blankSynonyms = MakeLexRef(m_synonym, new ICmObject[] {m_blank, m_ouch.SensesOS[0], m_blip.SensesOS[0], m_blipOuch, m_bother}); m_problem = MakeEntry("problem", "difficulty", false); m_problemSynonyms = MakeLexRef(m_synonym, new ICmObject[] { m_problem, m_trouble }); m_body = MakeEntry("body", "body", true); m_arm = MakeEntry("arm", "arm", false); m_leg = MakeEntry("leg", "leg", false); m_belly = MakeEntry("belly", "belly", true); m_torso = MakeEntry("torso", "torso", false); m_partWhole = MakeRefType("partWhole", null, (int)LexRefTypeTags.MappingTypes.kmtEntryTree); m_bodyParts = MakeLexRef(m_partWhole, new ICmObject[] {m_body, m_arm, m_leg.SensesOS[0], m_torso, m_belly}); m_torsoParts = MakeLexRef(m_partWhole, new ICmObject[] {m_torso, m_arm, m_belly}); m_hotBlank = MakeEntry("hotBlank", "problem rude word", false); MakeEntryRef(m_hotBlank, new ICmObject[] { m_trouble, m_water2 }, new ICmObject[] { m_trouble, m_water2 }, LexEntryRefTags.krtComplexForm); m_blueColor = MakeEntry("blue", "color blue", false); m_blueCold = MakeEntry("blue", "cold", false); m_blueMusic = MakeEntry("blue", "jazzy", false); m_blueSad = MakeEntry("blue", "sad", false); m_blueMusic.HomographNumber = 2; // will duplicate blue cold; pathological, but should not crash. m_blueSad.HomographNumber = 3; // will conflict with renumbered blueMusic m_bluer = m_blueColor.SensesOS[0]; m_sky = MakeEntry("sky", "interface between atmosphere and space", false, true); // true excludes as headword m_skyReal = m_sky.SensesOS[0]; m_blueSky = MakeEntry("blue sky", "clear, huge potential", false, false); m_blueSkyComponents = MakeEntryRef(m_blueSky, new ICmObject[] { m_blueColor, m_skyReal }, new[] { m_bluer, m_skyReal }, LexEntryRefTags.krtComplexForm); m_ringBell = MakeEntry("ring", "bell", false, false); m_ringCircle = MakeEntry("ring", "circle", false, true); m_ringGold = MakeEntry("ring", "gold", false, false); m_blackVerb = MakeEntry("black", "darken", false, true); m_blackColor = MakeEntry("black", "dark", false, false); m_hotArm = MakeEntry("hotarm", "pitcher", false, false); m_hotArmComponents = MakeEntryRef(m_hotArm, new ICmObject[] { m_hot, m_arm }, new[] { m_hot, m_arm }, LexEntryRefTags.krtComplexForm); m_hotArm.DoNotPublishInRC.Add(m_mainDict); m_hotArmComponents.ShowComplexFormsInRS.Add(m_hot); m_nolanryan = MakeEntry("Nolan_Ryan", "pitcher", false, false); m_nolanryanComponents = MakeEntryRef(m_nolanryan, new ICmObject[] { m_hot }, new[] { m_hot }, LexEntryRefTags.krtVariant); m_nolanryanComponents.VariantEntryTypesRS.Add( (ILexEntryType)Cache.LangProject.LexDbOA.VariantEntryTypesOA.PossibilitiesOS[0]); m_nolanryan.DoNotPublishInRC.Add(m_mainDict); m_edName = MakeEntry("ed", "someone called ed", false); m_edSuffix = MakeEntry("ed", "past", false, false, true); m_publisher = new MockPublisher((ISilDataAccessManaged)Cache.DomainDataByFlid, kmainFlid); m_publisher.SetOwningPropValue(Cache.LangProject.LexDbOA.Entries.Select(le => le.Hvo).ToArray()); m_decorator = new DictionaryPublicationDecorator(Cache, m_publisher, ObjectListPublisher.OwningFlid); }); }
/// <summary> /// The buckets are ordered in priority so adding a result to one bucket /// should remove that result from all lower (higher index) ones. /// N.B. Strategy subclasses should take care not to add a domain to a bucket /// if it is already in a higher priority bucket. /// </summary> /// <param name="bucketIndex"></param> /// <param name="domain"></param> public void AddResultToBucketX(int bucketIndex, ICmSemanticDomain domain) { m_bucketList[bucketIndex].Add(domain); for (var i = bucketIndex + 1; i < m_bucketList.Length; i++) { m_bucketList[i].Remove(domain); } }
private ILexSense AddLexSense(ILexEntry le, string defn, ICmSemanticDomain domain, IMoMorphSynAnalysis msa) { var servLoc = Cache.ServiceLocator; var ws = Cache.DefaultAnalWs; var ls = servLoc.GetInstance<ILexSenseFactory>().Create(); le.SensesOS.Add(ls); ls.Definition.set_String(ws, Cache.TsStrFactory.MakeString(defn, ws)); if (domain != null) ls.SemanticDomainsRC.Add(domain); var msaToAdd = msa ?? servLoc.GetInstance<IMoStemMsaFactory>().Create(); le.MorphoSyntaxAnalysesOC.Add(msaToAdd); ls.MorphoSyntaxAnalysisRA = msaToAdd; return ls; }
private void ReadQuestionsFromXml(XmlReader xrdrSub, ICmSemanticDomain semdom) { try { if (xrdrSub.IsEmptyElement) { xrdrSub.Read(); } else if (xrdrSub.ReadToDescendant("CmDomainQ")) { do { ReadDomainQFromXml(xrdrSub.ReadSubtree(), semdom); } while (xrdrSub.ReadToNextSibling("CmDomainQ")); } } finally { xrdrSub.Close(); } }
/// <summary> /// Take a string to look in (from a domain's Name or ExampleWords) and try to find /// a match for some (strategy-defined) search key(s). /// </summary> /// <param name="searchIn"></param> /// <param name="domain"></param> /// <param name="wholeWordBucket"></param> /// <returns></returns> protected bool CollectPossibleMatchIn(string searchIn, ICmSemanticDomain domain, int wholeWordBucket) { if (string.IsNullOrEmpty(searchIn)) return false; var wordsToLookIn = ParseStringIntoWords(searchIn); switch (DoesInputMatchWord(wordsToLookIn)) { case MatchingResult.WholeWordMatch: SearchResults.AddResultToBucketX(wholeWordBucket, domain); return true; case MatchingResult.StartOfWordMatch: SearchResults.AddResultToBucketX(wholeWordBucket + PartialMatchRelativeIndex, domain); return true; case MatchingResult.NoMatch: // do nothing break; default: throw new ApplicationException("Unknown MatchingResult"); } return false; }
private ILexEntry MakeLexEntry(string lf, string cf, string gloss, string defn, ICmSemanticDomain domain) { var le = MakeLexEntry(cf, defn, domain); var morph = Cache.ServiceLocator.GetInstance <IMoStemAllomorphFactory>().Create(); le.LexemeFormOA = morph; morph.Form.set_String(Cache.DefaultVernWs, lf); le.SensesOS[0].Gloss.set_String(Cache.DefaultAnalWs, gloss); return(le); }
public void RdeMerge() { if (Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Count < 5) { ICmSemanticDomainFactory factSemDom = Cache.ServiceLocator.GetInstance <ICmSemanticDomainFactory>(); while (Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Count < 5) { ICmSemanticDomain sem = factSemDom.Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(sem); } } IFdoOwningSequence <ICmPossibility> seqSemDom = Cache.LangProject.SemanticDomainListOA.PossibilitiesOS; ICmSemanticDomain semDom1 = seqSemDom[0] as ICmSemanticDomain; ICmSemanticDomain semDom2 = seqSemDom[1] as ICmSemanticDomain; ICmSemanticDomain semDom3 = seqSemDom[2] as ICmSemanticDomain; ICmSemanticDomain semDom4 = seqSemDom[4] as ICmSemanticDomain; // Create a LexEntry LE1 ("xyzTest1" defined as "xyzDefn1.1" in D1). // Attempt to merge it and verify that it survives. ILexEntry le1 = MakeLexEntry("xyzTest1", "xyzDefn1.1", semDom1); Set <int> newItems = new Set <int>(); ILexSense sense1 = le1.SensesOS[0]; newItems.Add(sense1.Hvo); // get an id for the 'list of senses' property (which isn't in the model) int fakeFlid = (int)CmObjectFields.kflidStartDummyFlids + 1; List <XmlNode> columns = new List <XmlNode>(); bool fSenseDeleted = sense1.RDEMergeSense(semDom1.Hvo, columns, Cache, newItems); Assert.IsFalse(fSenseDeleted, "RDEMergeSense 1: sense should not be deleted"); Assert.IsTrue(IsRealLexEntry(le1)); Assert.IsTrue(le1.SensesOS[0].SemanticDomainsRC.Contains(semDom1)); // Attempt to merge them both. // Verify that LE3 survives. // Verify that old LE1 survives and now has two senses; new sense has xyzDefn1.2. // Verify that LE2 is deleted and LE3 survives. ILexEntry le2 = MakeLexEntry("xyzTest1", "xyzDefn1.2", semDom2); Set <int> newItems2 = new Set <int>(); ILexSense sense2 = le2.SensesOS[0]; newItems2.Add(sense2.Hvo); ILexEntry le3 = MakeLexEntry("xyzTest3", "xyzDefn3.1", semDom2); ILexSense sense3 = le3.SensesOS[0]; newItems2.Add(sense3.Hvo); fSenseDeleted = sense2.RDEMergeSense(semDom2.Hvo, columns, Cache, newItems2); Assert.IsFalse(fSenseDeleted, "RDEMergeSense 2: sense should not be deleted"); fSenseDeleted = sense3.RDEMergeSense(semDom2.Hvo, columns, Cache, newItems2); Assert.IsFalse(fSenseDeleted, "RDEMergeSense 3: sense should not be deleted"); Assert.IsTrue(IsRealLexEntry(le3)); Assert.IsFalse(IsRealLexEntry(le2), "entry should be deleted"); Assert.IsTrue(IsRealLexEntry(le1)); Assert.AreEqual(2, le1.SensesOS.Count, "sense added to entry by merge"); Assert.AreEqual(1, le3.SensesOS.Count, "should still be one sense"); Assert.AreEqual("xyzDefn1.2", le1.SensesOS[1].Definition.AnalysisDefaultWritingSystem.Text); Assert.IsTrue(le1.SensesOS[1].SemanticDomainsRC.Contains(semDom2)); Assert.IsTrue(le3.SensesOS[0].SemanticDomainsRC.Contains(semDom2)); // Create two more entries LE4("xyzTest1/xyzDefn1.2/D3" and LE5 ("xyzTest1/xyzDefn1.3/D3"). // Verify that the second sense of LE1 gains a domain; // It also gains exactly one new sense; // And LE4 and LE5 are both deleted. ILexEntry le4 = MakeLexEntry("xyzTest1", "xyzDefn1.2", semDom3); Set <int> newItems3 = new Set <int>(); ILexSense sense4 = le4.SensesOS[0]; newItems3.Add(sense4.Hvo); ILexEntry le5 = MakeLexEntry("xyzTest1", "xyzDefn1.3", semDom3); ILexSense sense5 = le5.SensesOS[0]; newItems3.Add(sense5.Hvo); fSenseDeleted = sense4.RDEMergeSense(semDom3.Hvo, columns, Cache, newItems3); Assert.IsTrue(fSenseDeleted, "RDEMergeSense 4: sense should be deleted"); fSenseDeleted = sense5.RDEMergeSense(semDom3.Hvo, columns, Cache, newItems3); Assert.IsFalse(fSenseDeleted, "RDEMergeSense 5: sense should not be deleted"); Assert.IsTrue(IsRealLexEntry(le3)); Assert.IsFalse(IsRealLexEntry(le4)); Assert.IsFalse(IsRealLexEntry(le5)); Assert.IsTrue(IsRealLexEntry(le1)); Assert.AreEqual(3, le1.SensesOS.Count, "one sense added to entry by merge"); Assert.AreEqual("xyzDefn1.3", le1.SensesOS[2].Definition.AnalysisDefaultWritingSystem.Text); Assert.IsTrue(le1.SensesOS[2].SemanticDomainsRC.Contains(semDom3)); int[] sense2Domains = le1.SensesOS[1].SemanticDomainsRC.ToHvoArray(); Assert.AreEqual(2, sense2Domains.Length, "got 2 semantic domains on sense 2"); int minDom = Math.Min(semDom2.Hvo, semDom3.Hvo); // smaller of expected domains. int maxDom = Math.Max(semDom2.Hvo, semDom3.Hvo); int minActual = Math.Min(sense2Domains[0], sense2Domains[1]); int maxActual = Math.Max(sense2Domains[0], sense2Domains[1]); Assert.AreEqual(minDom, minActual, "expected domains on merged sense"); Assert.AreEqual(maxDom, maxActual, "expected domains on merged sense"); // Try adding four senses, three for the same CF, but which doesn't pre-exist. // Also, the three are exact duplicates. ILexEntry le6 = MakeLexEntry("xyzTest6", "xyzDefn6.1", semDom4); Set <int> newItems4 = new Set <int>(); ILexSense sense6 = le6.SensesOS[0]; newItems4.Add(sense6.Hvo); ILexEntry le7 = MakeLexEntry("xyzTest6", "xyzDefn6.1", semDom4); ILexSense sense7 = le7.SensesOS[0]; newItems4.Add(sense7.Hvo); ILexEntry le8 = MakeLexEntry("xyzTest6", "xyzDefn6.1", semDom4); ILexSense sense8 = le8.SensesOS[0]; newItems4.Add(sense8.Hvo); fSenseDeleted = sense6.RDEMergeSense(semDom4.Hvo, columns, Cache, newItems4); Assert.IsFalse(fSenseDeleted, "RDEMergeSense 6: sense should not be deleted"); fSenseDeleted = sense7.RDEMergeSense(semDom4.Hvo, columns, Cache, newItems4); Assert.IsTrue(fSenseDeleted, "RDEMergeSense 7: sense should be deleted"); fSenseDeleted = sense8.RDEMergeSense(semDom4.Hvo, columns, Cache, newItems4); Assert.IsTrue(fSenseDeleted, "RDEMergeSense 8: sense should be deleted"); Assert.IsTrue(IsRealLexEntry(le6)); Assert.IsFalse(IsRealLexEntry(le7)); Assert.IsFalse(IsRealLexEntry(le8)); Assert.AreEqual(1, le6.SensesOS.Count, "one sense survives merge"); }
/// <summary> /// Don't count references to Semantic Domains from other Semantic Domains. /// The user only cares about how many times in the lexicon the Semantic Domain is used. /// </summary> /// <param name="domain"></param> /// <returns></returns> public static int SenseReferenceCount(ICmSemanticDomain domain) { int count = 0; if (domain.ReferringObjects != null) count = (from item in domain.ReferringObjects where item is ILexSense select item).Count(); return count; }
private void ReadDomainQFromXml(XmlReader xrdrSub, ICmSemanticDomain semdom) { try { Dictionary<string, ICmDomainQ> mapQuest2Obj = new Dictionary<string, ICmDomainQ>(); foreach (var dq in semdom.QuestionsOS) { ITsString tssQuest = dq.Question.get_String(m_wsEn); if (tssQuest == null) continue; string quest = tssQuest.Text; if (String.IsNullOrEmpty(quest)) continue; if (!mapQuest2Obj.ContainsKey(quest)) mapQuest2Obj.Add(quest, dq); } ICmDomainQ cdq = null; string wordsXml = null; string sentencesXml = null; while (xrdrSub.Read()) { if (xrdrSub.NodeType == XmlNodeType.Element) { switch (xrdrSub.Name) { case "CmDomainQ": break; case "Question": cdq = FindQuestionAndSetIt(xrdrSub, mapQuest2Obj); if (!String.IsNullOrEmpty(wordsXml)) { using (var srdr = new StringReader(wordsXml)) { using (var xrdrWords = XmlReader.Create(srdr)) { SetMultiUnicodeFromXml(xrdrWords, cdq.ExampleWords); xrdrWords.Close(); wordsXml = null; } } } if (!String.IsNullOrEmpty(sentencesXml)) { using (var srdr = new StringReader(sentencesXml)) { using (var xrdrSentences = XmlReader.Create(srdr)) { SetMultiStringFromXml(xrdrSentences, cdq.ExampleSentences); xrdrSentences.Close(); wordsXml = null; } } } break; case "ExampleWords": if (cdq == null) wordsXml = GetXmlOfElement(xrdrSub); else SetMultiUnicodeFromXml(xrdrSub, cdq.ExampleWords); break; case "ExampleSentences": if (cdq == null) sentencesXml = GetXmlOfElement(xrdrSub); else SetMultiStringFromXml(xrdrSub, cdq.ExampleSentences); break; default: StoreOrReportUnexpectedElement(cdq, xrdrSub, "CmSemanticDomain/Questions/CmDomainQ"); break; } } } } finally { xrdrSub.Close(); } }
/// <summary> /// Get the text from a Semantic Domain's Name field. /// This version uses AnalysisDefault ws which may not always have a value /// (i.e. be prepared for a null return value). /// </summary> /// <param name="domain"></param> /// <returns></returns> protected override string GetDomainNameString(ICmSemanticDomain domain) { return(domain.Name.get_String(CurrentWs).Text); }
public void RdeMerge_ExtraFields() { ICmSemanticDomainFactory factSemDom = Cache.ServiceLocator.GetInstance <ICmSemanticDomainFactory>(); ICmSemanticDomain semDom1 = factSemDom.Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(semDom1); ICmSemanticDomain semDom2 = factSemDom.Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(semDom2); ICmSemanticDomain semDom3 = factSemDom.Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(semDom3); List <XmlNode> columns = new List <XmlNode>(); // Create a LexEntry LE1 (cf "red" gloss "rot" in D1, with bibliographic data). // Attempt to merge it and verify that it survives. ILexEntry red = MakeLexEntry("red", "", "rot", "", semDom1); // After creating similar entry in another domain with same info, should merge. var red2 = MakeLexEntry("red", "", "rot", "", semDom2); red2.Bibliography.set_String(Cache.DefaultAnalWs, "found in my dictionary"); red2.SensesOS[0].SemanticsNote.set_String(Cache.DefaultVernWs, "color of a stop light"); red2.SensesOS[0].ScientificName = MakeAnalysisString("R=255,G=0,B=0"); var ex1 = Cache.ServiceLocator.GetInstance <ILexExampleSentenceFactory>().Create(); red2.SensesOS[0].ExamplesOS.Add(ex1); bool fSenseDeleted = RunMergeSense(columns, red2); Assert.IsTrue(fSenseDeleted, "Merging red/rot with matching lf/gloss should merge and delete new sense"); Assert.IsFalse(IsRealLexEntry(red2), "Merging with red/rot with matching lf/gloss should delete entry"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should add new semantic domain"); Assert.That(red.Bibliography.AnalysisDefaultWritingSystem.Text, Is.EqualTo("found in my dictionary"), "merge should copy bibliography"); Assert.That(red.SensesOS[0].SemanticsNote.VernacularDefaultWritingSystem.Text, Is.EqualTo("color of a stop light"), "merge should copy semantics note"); Assert.That(red.SensesOS[0].ScientificName.Text, Is.EqualTo("R=255,G=0,B=0"), "merge should copy scientific name"); Assert.That(red.SensesOS[0].ExamplesOS, Has.Member(ex1), "merge should move example"); // Another similar entry should merge, adding to the bibliography. var red3 = MakeLexEntry("red", "", "rot", "", semDom3); red3.Bibliography.set_String(Cache.DefaultAnalWs, "learned at mother's knee"); red3.SensesOS[0].SemanticsNote.set_String(Cache.DefaultVernWs, "color of danger"); red3.SensesOS[0].ScientificName = MakeAnalysisString("C=0, M=100, Y=100, K=0"); var ex2 = Cache.ServiceLocator.GetInstance <ILexExampleSentenceFactory>().Create(); red3.SensesOS[0].ExamplesOS.Add(ex2); fSenseDeleted = RunMergeSense(columns, red3); Assert.IsTrue(fSenseDeleted, "Merging red/rot with matching lf/gloss and new defn should merge and delete new sense"); Assert.IsFalse(IsRealLexEntry(red3), "Merging with red/rot with matching lf/gloss and new defn should delete entry"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should not remove old semantic domain"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom3), "Merging should add new semantic domain"); Assert.That(red.Bibliography.AnalysisDefaultWritingSystem.Text, Is.EqualTo("found in my dictionary; learned at mother's knee"), "merge should append bibliography"); Assert.That(red.SensesOS[0].SemanticsNote.VernacularDefaultWritingSystem.Text, Is.EqualTo("color of a stop light; color of danger"), "merge should append semantics note"); Assert.That(red.SensesOS[0].ScientificName.Text, Is.EqualTo("R=255,G=0,B=0; C=0, M=100, Y=100, K=0"), "merge should append scientific name"); Assert.That(red.SensesOS[0].ExamplesOS, Has.Member(ex1), "merge should leave original example"); Assert.That(red.SensesOS[0].ExamplesOS, Has.Member(ex2), "merge should move second example"); }
private void ReadDomainQFromXml(XmlReader xrdrSub, ICmSemanticDomain semdom) { try { Dictionary <string, ICmDomainQ> mapQuest2Obj = new Dictionary <string, ICmDomainQ>(); foreach (var dq in semdom.QuestionsOS) { ITsString tssQuest = dq.Question.get_String(m_wsEn); if (tssQuest == null) { continue; } string quest = tssQuest.Text; if (String.IsNullOrEmpty(quest)) { continue; } if (!mapQuest2Obj.ContainsKey(quest)) { mapQuest2Obj.Add(quest, dq); } } ICmDomainQ cdq = null; string wordsXml = null; string sentencesXml = null; while (xrdrSub.Read()) { if (xrdrSub.NodeType == XmlNodeType.Element) { switch (xrdrSub.Name) { case "CmDomainQ": break; case "Question": cdq = FindQuestionAndSetIt(xrdrSub, mapQuest2Obj); if (!String.IsNullOrEmpty(wordsXml)) { using (var srdr = new StringReader(wordsXml)) { using (var xrdrWords = XmlReader.Create(srdr)) { SetMultiUnicodeFromXml(xrdrWords, cdq.ExampleWords); xrdrWords.Close(); wordsXml = null; } } } if (!String.IsNullOrEmpty(sentencesXml)) { using (var srdr = new StringReader(sentencesXml)) { using (var xrdrSentences = XmlReader.Create(srdr)) { SetMultiStringFromXml(xrdrSentences, cdq.ExampleSentences); xrdrSentences.Close(); wordsXml = null; } } } break; case "ExampleWords": if (cdq == null) { wordsXml = GetXmlOfElement(xrdrSub); } else { SetMultiUnicodeFromXml(xrdrSub, cdq.ExampleWords); } break; case "ExampleSentences": if (cdq == null) { sentencesXml = GetXmlOfElement(xrdrSub); } else { SetMultiStringFromXml(xrdrSub, cdq.ExampleSentences); } break; default: StoreOrReportUnexpectedElement(cdq, xrdrSub, "CmSemanticDomain/Questions/CmDomainQ"); break; } } } } finally { xrdrSub.Close(); } }
public void RdeMerge_GlossAndCf() { if (Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Count < 5) { ICmSemanticDomainFactory factSemDom = Cache.ServiceLocator.GetInstance <ICmSemanticDomainFactory>(); while (Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Count < 5) { ICmSemanticDomain sem = factSemDom.Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(sem); } } IFdoOwningSequence <ICmPossibility> seqSemDom = Cache.LangProject.SemanticDomainListOA.PossibilitiesOS; ICmSemanticDomain semDom1 = seqSemDom[0] as ICmSemanticDomain; ICmSemanticDomain semDom2 = seqSemDom[1] as ICmSemanticDomain; ICmSemanticDomain semDom3 = seqSemDom[2] as ICmSemanticDomain; ICmSemanticDomain semDom4 = seqSemDom[4] as ICmSemanticDomain; // Create a LexEntry LE1 (cf "red" gloss "rot" in D1). // Attempt to merge it and verify that it survives. ILexEntry red = MakeLexEntry("red", "", "rot", "", semDom1); Set <int> newItems = new Set <int>(); ILexSense sense1 = red.SensesOS[0]; newItems.Add(sense1.Hvo); List <XmlNode> columns = new List <XmlNode>(); bool fSenseDeleted = RunMergeSense(columns, red); Assert.IsFalse(fSenseDeleted, "Merging red when there is no similar item should not delete sense"); Assert.IsTrue(IsRealLexEntry(red), "Merging with no similar entry should not delete entry"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove semantic domain"); // After creating similar entry in another domain with same info, should merge. var red2 = MakeLexEntry("red", "", "rot", "", semDom2); fSenseDeleted = RunMergeSense(columns, red2); Assert.IsTrue(fSenseDeleted, "Merging red/rot with matching lf/gloss should merge and delete new sense"); Assert.IsFalse(IsRealLexEntry(red2), "Merging with red/rot with matching lf/gloss should delete entry"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should add new semantic domain"); // Another similar entry should merge, adding definition. var red3 = MakeLexEntry("red", "", "rot", "rot2", semDom3); fSenseDeleted = RunMergeSense(columns, red3); Assert.IsTrue(fSenseDeleted, "Merging red/rot with matching lf/gloss and new defn should merge and delete new sense"); Assert.IsFalse(IsRealLexEntry(red3), "Merging with red/rot with matching lf/gloss and new defn should delete entry"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should not remove old semantic domain"); Assert.IsTrue(red.SensesOS[0].SemanticDomainsRC.Contains(semDom3), "Merging should add new semantic domain"); Assert.That(red.SensesOS[0].Definition.AnalysisDefaultWritingSystem.Text, Is.EqualTo("rot2")); // Similarly we should be able to start with a matching definition, and add a gloss. var blue = MakeLexEntry("blue", "", "", "blau", semDom1); var blue2 = MakeLexEntry("blue", "", "blauG", "blau", semDom2); fSenseDeleted = RunMergeSense(columns, blue2); Assert.IsTrue(fSenseDeleted, "Merging blue/blau with matching lf/defn and new gloss should merge and delete new sense"); Assert.IsFalse(IsRealLexEntry(blue2), "Merging blue/blau with matching lf/defn and new gloss should delete entry"); Assert.IsTrue(blue.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(blue.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should add new semantic domain"); Assert.That(blue.SensesOS[0].Gloss.AnalysisDefaultWritingSystem.Text, Is.EqualTo("blauG")); // Conflicts in another writing system should prevent merging var blue3 = MakeLexEntry("blue", "", "blauG", "blau", semDom3); var wsEs = Cache.WritingSystemFactory.GetWsFromStr("es"); blue.SensesOS[0].Gloss.set_String(wsEs, "blueS"); blue3.SensesOS[0].Gloss.set_String(wsEs, "blueS3"); fSenseDeleted = RunMergeSense(columns, blue3); Assert.IsFalse(fSenseDeleted, "Merging blue/blau with matching lf/defn/gloss but different gloss in spanish should not delete sense"); Assert.IsFalse(IsRealLexEntry(blue3), "Merging blue/blau with matching lf/defn/gloss but different gloss in spanish should delete entry"); Assert.IsTrue(blue.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(blue.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should not remove old semantic domain"); Assert.IsTrue(blue.SensesOS[1].SemanticDomainsRC.Contains(semDom3), "Merging should not remove old semantic domain"); // A conflicting lex entry, even though a homograph in the current relevant writing system, should prevent merging, // even though the sense data all matches blue.CitationForm.set_String(Cache.DefaultVernWs, "blueCf"); var blue4 = MakeLexEntry("blueForm2", "blueCf", "blauG", "blau", semDom4); fSenseDeleted = RunMergeSense(columns, blue4); Assert.IsFalse(fSenseDeleted, "Merging blueCf/blau with matching lf/defn/gloss but different lexeme form should not delete sense"); Assert.IsTrue(IsRealLexEntry(blue4), "Merging blueCf/blau with matching lf/defn/gloss but different lexeme form should not delete entry"); Assert.IsTrue(blue.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(blue.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should not remove old semantic domain"); Assert.IsTrue(blue4.SensesOS[0].SemanticDomainsRC.Contains(semDom4), "Merging should not remove old semantic domain"); // This case demonstrates that we can merge when the existing entry has no lexeme form, filling in the one we have. // We can also fill in other WS alternatives. var green = MakeLexEntry("", "greenF", "grun", "color grun", semDom1); var green2 = MakeLexEntry("green", "greenF", "grun", "color grun", semDom2); green2.CitationForm.set_String(wsEs, "grunCfS"); green2.LexemeFormOA.Form.set_String(wsEs, "grunS"); fSenseDeleted = RunMergeSense(columns, green2); Assert.IsTrue(fSenseDeleted, "Merging green/grun with matching cf/defn/gloss and one missing LF should delete sense"); Assert.IsFalse(IsRealLexEntry(green2), "Merging blueCf/blau with matching lf/defn/gloss but different lexeme form should not delete entry"); Assert.IsTrue(green.SensesOS[0].SemanticDomainsRC.Contains(semDom1), "Merging should not remove old semantic domain"); Assert.IsTrue(green.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should not remove old semantic domain"); Assert.That(green.LexemeFormOA.Form.VernacularDefaultWritingSystem.Text, Is.EqualTo("green"), "merge should fill in missing LF"); Assert.That(green.LexemeFormOA.Form.get_String(wsEs).Text, Is.EqualTo("grunS"), "merge should fill in missing spanish LF"); Assert.That(green.CitationForm.get_String(wsEs).Text, Is.EqualTo("grunCfS"), "merge should fill in missing spanish CF"); // We should not merge when NO non-empty string matches. var brown = MakeLexEntry("brown", "", "braun", "", semDom1); var brown2 = MakeLexEntry("brown", "", "", "braun color", semDom2); fSenseDeleted = RunMergeSense(columns, brown2); Assert.IsFalse(fSenseDeleted, "Merging two forms of brown with no overlap between gloss and defn should not delete sense"); // But as a special case we can merge if definition of one matches gloss of other. var brown3 = MakeLexEntry("brown", "", "", "braun", semDom2); fSenseDeleted = RunMergeSense(columns, brown3); Assert.IsTrue(fSenseDeleted, "Merging two forms of brown with no gloss of one equal to defn of other should delete sense"); Assert.IsTrue(brown.SensesOS[0].SemanticDomainsRC.Contains(semDom2), "Merging should combine semantic domains"); Assert.That(brown.SensesOS[0].Definition.AnalysisDefaultWritingSystem.Text, Is.EqualTo("braun"), "Merging should copy definition"); // We want to match entries that have the same LexemeForm even if they are not homographs. // This is possible if one of them has an empty CF in the homograph writing system. var orange = MakeLexEntry("orange", "orangeCf", "orang", "", semDom1); var orange2 = MakeLexEntry("orange", "", "orang", "", semDom2); fSenseDeleted = RunMergeSense(columns, orange2); Assert.IsTrue(fSenseDeleted, "Merging two forms of orange with matching LF and new blank Cf should delete sense"); var pink = MakeLexEntry("pink", "", "rose", "", semDom1); var pink2 = MakeLexEntry("pink", "pinkCf", "rose", "", semDom2); fSenseDeleted = RunMergeSense(columns, pink2); Assert.IsTrue(fSenseDeleted, "Merging two forms of pink with matching LF and old blank Cf should delete sense"); Assert.That(pink.CitationForm.VernacularDefaultWritingSystem.Text, Is.EqualTo("pinkCf"), "merge should fill in missing CF"); // An inexact match that moves a sense should still fill in missing info on the chosen entry. var yellow = MakeLexEntry("yellow", "", "flower", "", semDom1); var yellow2 = MakeLexEntry("yellow", "yellowCf", "floral", "", semDom2); fSenseDeleted = RunMergeSense(columns, yellow2); Assert.IsFalse(fSenseDeleted, "Merging two forms of yellow with matching LF and old blank Cf should delete sense"); Assert.That(yellow.CitationForm.VernacularDefaultWritingSystem.Text, Is.EqualTo("yellowCf"), "merge should fill in missing CF"); }
private void CacheDomain(ICmSemanticDomain domain) { // Check for whole word matches in Name and ExampleWords CacheWordsIn(GetDomainNameString(domain), domain); CacheWordsIn(GetExampleWordsString(domain.QuestionsOS), domain); }
private void ReadDomainQuestion(XmlReader xrdrSub, ICmSemanticDomain dom) { try { ICmDomainQ domQ = null; while (xrdrSub.Read()) { if (xrdrSub.NodeType == XmlNodeType.Element) { switch (xrdrSub.Name) { case "ExampleSentences": if (domQ == null) { domQ = m_factCmDomainQ.Create(); dom.QuestionsOS.Add(domQ); } SetMultiStringFromXml(xrdrSub, domQ.ExampleSentences); break; case "ExampleWords": if (domQ == null) { domQ = m_factCmDomainQ.Create(); dom.QuestionsOS.Add(domQ); } SetMultiUnicodeFromXml(xrdrSub, domQ.ExampleWords); break; case "Question": if (domQ == null) { domQ = m_factCmDomainQ.Create(); dom.QuestionsOS.Add(domQ); } SetMultiUnicodeFromXml(xrdrSub, domQ.Question); break; } } } } finally { xrdrSub.Close(); } }
private ILexEntry MakeLexEntry(string lf, string cf, string gloss, string defn, ICmSemanticDomain domain) { var le = MakeLexEntry(cf, defn, domain); var morph = Cache.ServiceLocator.GetInstance<IMoStemAllomorphFactory>().Create(); le.LexemeFormOA = morph; morph.Form.set_String(Cache.DefaultVernWs, lf); le.SensesOS[0].Gloss.set_String(Cache.DefaultAnalWs, gloss); return le; }
private void CacheDomain(ICmSemanticDomain domain) { // Check for whole word matches in Name and ExampleWords CacheWordsIn(GetDomainNameString(domain), domain); CacheWordsIn(GetExampleWordsString(domain.QuestionsOS), domain); }
private void SearchInAbbreviationForMatches(ICmSemanticDomain domain) { if (domain.Abbreviation.BestAnalysisAlternative.Text.StartsWith(m_searchString)) SearchResults.AddResultToBucketX(0, domain); }
/// <summary> /// Get the text from a Semantic Domain's Name field. /// </summary> /// <param name="domain"></param> /// <returns>an array of Tuples, where each Tuple has a ws handle and a name string</returns> private static Tuple<int, string>[] GetDomainNameString(ICmSemanticDomain domain) { var name = domain.Name; return name.AvailableWritingSystemIds.Select(ws => new Tuple<int, string>( ws, name.get_String(ws).Text)).Where(tuple => !String.IsNullOrEmpty(tuple.Item2)).ToArray(); }
ICmSemanticDomain ICmSemanticDomainFactory.Create(Guid guid, ICmSemanticDomain owner) { if (owner == null) throw new ArgumentNullException("owner"); int hvo = ((IDataReader)m_cache.ServiceLocator.GetInstance<IDataSetup>()).GetNextRealHvo(); int flid = m_cache.MetaDataCache.GetFieldId("CmPossibility", "SubPossibilities", false); var retval = new CmSemanticDomain(m_cache, hvo, guid); owner.SubPossibilitiesOS.Add(retval); return retval; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="cf"></param> /// <param name="defn"></param> /// <param name="domain">May be null.</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ private ILexEntry MakeLexEntry(string cf, string defn, ICmSemanticDomain domain) { var servLoc = Cache.ServiceLocator; var le = servLoc.GetInstance<ILexEntryFactory>().Create(); var ws = Cache.DefaultVernWs; le.CitationForm.set_String(ws, Cache.TsStrFactory.MakeString(cf, ws)); AddLexSense(le, defn, domain, null); return le; }
private void AddSemanticDomainToSense(ILexSense understand, ICmSemanticDomain oilSemDom) { NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () => understand.SemanticDomainsRC.Add(oilSemDom)); }