public void CliticVsStemMsaWithoutCategory()
{
CheckDisposed();
LexEntry entry = new LexEntry();
Cache.LangProject.LexDbOA.EntriesOC.Add(entry);
MoStemAllomorph allomorph = new MoStemAllomorph();
entry.LexemeFormOA = allomorph;
MoStemMsa msa = new MoStemMsa();
entry.MorphoSyntaxAnalysesOC.Add(msa);
SetMorphType(allomorph, MoMorphType.kguidMorphClitic);
Assert.AreEqual("Clitic of unknown category", msa.LongNameTs.Text);
MoStemAllomorph allo2 = new MoStemAllomorph();
entry.AlternateFormsOS.Append(allo2);
SetMorphType(allomorph, MoMorphType.kguidMorphStem);
Assert.AreEqual("Stem/root of unknown category; takes any affix", msa.LongNameTs.Text);
}
public void FromPartsOfSpeechIsRelevant()
{
CheckDisposed();
LexEntry entry = new LexEntry();
Cache.LangProject.LexDbOA.EntriesOC.Add(entry);
MoStemAllomorph allomorph = new MoStemAllomorph();
entry.AlternateFormsOS.Append(allomorph);
MoStemMsa msa = new MoStemMsa();
entry.MorphoSyntaxAnalysesOC.Add(msa);
SetMorphType(allomorph, MoMorphType.kguidMorphStem);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphProclitic);
Assert.IsTrue(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should now be relevant since the entry has a proclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphEnclitic);
Assert.IsTrue(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should now be relevant since the entry has an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphClitic);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphBoundRoot);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphBoundStem);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphCircumfix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphDiscontiguousPhrase);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphInfix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphInfixingInterfix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphParticle);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphPhrase);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphPrefix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphPrefixingInterfix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphRoot);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphSimulfix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphSuffix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphSuffixingInterfix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
SetMorphType(allomorph, MoMorphType.kguidMorphSuprafix);
Assert.IsFalse(msa.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidFromPartsOfSpeech),
"FromPartsOfSpeech should not be relevant until the entry contains a proclitic or an enclitic.");
}
public void MoDerivAffMsa_EqualMsa()
{
CheckDisposed();
CreateTestData();
ILangProject lp = Cache.LangProject;
ILexDb ld = lp.LexDbOA;
ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
MoDerivAffMsa derivAffixMsa1 = new MoDerivAffMsa();
MoDerivAffMsa derivAffixMsa2 = new MoDerivAffMsa();
MoStemMsa stemMsa = new MoStemMsa();
MoInflAffMsa inflAffixMsa = new MoInflAffMsa();
MoUnclassifiedAffixMsa unclassifiedAffixMsa = new MoUnclassifiedAffixMsa();
le.MorphoSyntaxAnalysesOC.Add(derivAffixMsa1);
le.MorphoSyntaxAnalysesOC.Add(derivAffixMsa2);
le.MorphoSyntaxAnalysesOC.Add(stemMsa);
le.MorphoSyntaxAnalysesOC.Add(inflAffixMsa);
le.MorphoSyntaxAnalysesOC.Add(unclassifiedAffixMsa);
DummyGenericMSA dummyMsa1 = DummyGenericMSA.Create(derivAffixMsa1);
DummyGenericMSA dummyMsa2 = DummyGenericMSA.Create(derivAffixMsa2);
DummyGenericMSA dummyMsa3 = DummyGenericMSA.Create(stemMsa);
DummyGenericMSA dummyMsa4 = DummyGenericMSA.Create(inflAffixMsa);
DummyGenericMSA dummyMsa5 = DummyGenericMSA.Create(unclassifiedAffixMsa);
// Verify we fail comparing on different MSA types.
Assert.IsFalse(derivAffixMsa1.EqualsMsa(stemMsa));
Assert.IsFalse(derivAffixMsa1.EqualsMsa(inflAffixMsa));
Assert.IsFalse(derivAffixMsa1.EqualsMsa(unclassifiedAffixMsa));
Assert.IsFalse(derivAffixMsa1.EqualsMsa(dummyMsa3));
Assert.IsFalse(derivAffixMsa1.EqualsMsa(dummyMsa4));
Assert.IsFalse(derivAffixMsa1.EqualsMsa(dummyMsa5));
// Verify that derivAffixMsa1 equals itself.
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa1), derivAffixMsa1.ToString() + " - should equal itself.");
// Verify that derivAffixMsa1 equals derivAffixMsa2
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), derivAffixMsa1.ToString() + " - should equal - " + derivAffixMsa2.ToString());
Assert.IsTrue(derivAffixMsa1.EqualsMsa(dummyMsa2), "derivAffixMsa1 should equal dummyMsa2");
// compare with on different FromPartOfSpeech
FdoOwningSequence<ICmPossibility> posSeq = lp.PartsOfSpeechOA.PossibilitiesOS;
IPartOfSpeech pos1 = (IPartOfSpeech)posSeq.Append(new PartOfSpeech());
IPartOfSpeech pos2 = (IPartOfSpeech)posSeq.Append(new PartOfSpeech());
derivAffixMsa1.FromPartOfSpeechRA = pos1;
derivAffixMsa2.FromPartOfSpeechRA = pos2;
dummyMsa2.MainPOS = pos2.Hvo;
Assert.IsTrue(derivAffixMsa1.FromPartOfSpeechRA != derivAffixMsa2.FromPartOfSpeechRA, "msa POSes should not be equal.");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to different FromPartOfSpeech");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(dummyMsa2), "derivAffixMsa1 should not equal dummyMsa2");
// reset POS
derivAffixMsa1.FromPartOfSpeechRAHvo = derivAffixMsa2.FromPartOfSpeechRAHvo;
dummyMsa2.MainPOS = derivAffixMsa1.FromPartOfSpeechRAHvo;
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching POS");
Assert.IsTrue(derivAffixMsa1.EqualsMsa(dummyMsa2), "derivAffixMsa1 should equal dummyMsa2");
// compare with on different ToPartOfSpeech
PartOfSpeech pos3 = (PartOfSpeech)posSeq.Append(new PartOfSpeech());
PartOfSpeech pos4 = (PartOfSpeech)posSeq.Append(new PartOfSpeech());
derivAffixMsa1.ToPartOfSpeechRA = pos3;
derivAffixMsa2.ToPartOfSpeechRA = pos4;
dummyMsa2.SecondaryPOS = pos4.Hvo;
Assert.IsTrue(derivAffixMsa1.ToPartOfSpeechRA != derivAffixMsa2.ToPartOfSpeechRA, "msa POSes should not be equal.");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to different ToPartOfSpeech");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(dummyMsa2), "derivAffixMsa1 should not equal dummyMsa2");
// reset POS
derivAffixMsa1.ToPartOfSpeechRAHvo = derivAffixMsa2.ToPartOfSpeechRAHvo;
dummyMsa2.SecondaryPOS = derivAffixMsa1.ToPartOfSpeechRAHvo;
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching POS");
Assert.IsTrue(derivAffixMsa1.EqualsMsa(dummyMsa2), "derivAffixMsa1 should equal dummyMsa2");
// compare on different FromInflectionClass
pos1.InflectionClassesOC.Add(new MoInflClass());
pos2.InflectionClassesOC.Add(new MoInflClass());
derivAffixMsa1.FromInflectionClassRAHvo = pos1.InflectionClassesOC.HvoArray[0];
derivAffixMsa2.FromInflectionClassRAHvo = pos2.InflectionClassesOC.HvoArray[0];
Assert.IsTrue(derivAffixMsa1.FromInflectionClassRA != derivAffixMsa2.FromInflectionClassRA, "inflection classes should not be equal.");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to different inflection classes.");
// reset InflectionClass
derivAffixMsa1.FromInflectionClassRA = derivAffixMsa2.FromInflectionClassRA;
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching inflection classes");
// compare on different FromStemName
pos1.StemNamesOC.Add(new MoStemName());
pos2.StemNamesOC.Add(new MoStemName());
derivAffixMsa1.FromStemNameRAHvo = pos1.StemNamesOC.HvoArray[0];
derivAffixMsa2.FromStemNameRAHvo = pos2.StemNamesOC.HvoArray[0];
Assert.IsTrue(derivAffixMsa1.FromStemNameRA != derivAffixMsa2.FromStemNameRA, "stem names should not be equal.");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to different stem names.");
// reset StemName
derivAffixMsa1.FromStemNameRA = derivAffixMsa2.FromStemNameRA;
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching stem names");
// compare on different ToInflectionClass
pos3.InflectionClassesOC.Add(new MoInflClass());
pos4.InflectionClassesOC.Add(new MoInflClass());
derivAffixMsa1.ToInflectionClassRAHvo = pos3.InflectionClassesOC.HvoArray[0];
derivAffixMsa2.ToInflectionClassRAHvo = pos4.InflectionClassesOC.HvoArray[0];
Assert.IsTrue(derivAffixMsa1.ToInflectionClassRA != derivAffixMsa2.ToInflectionClassRA, "inflection classes should not be equal.");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to different inflection classes.");
// reset InflectionClass
derivAffixMsa1.ToInflectionClassRA = derivAffixMsa2.ToInflectionClassRA;
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching inflection classes");
// compare different FromProdRestrict
ICmPossibility pr1 = lp.MorphologicalDataOA.ProdRestrictOA.PossibilitiesOS[0];
ICmPossibility pr2 = lp.MorphologicalDataOA.ProdRestrictOA.PossibilitiesOS[1];
derivAffixMsa1.FromProdRestrictRC.Add(pr1.Hvo);
derivAffixMsa2.FromProdRestrictRC.Add(pr2.Hvo);
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to productivity restrictions differences.");
derivAffixMsa1.FromProdRestrictRC.Add(pr2.Hvo);
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to productivity restrictions count difference.");
// Match Productivity Restrictions
derivAffixMsa2.FromProdRestrictRC.Add(pr1.Hvo);
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching productivity restrictions");
// compare different ToProdRestrict
CmPossibility pr3 = lp.MorphologicalDataOA.ProdRestrictOA.PossibilitiesOS[2] as CmPossibility;
CmPossibility pr4 = lp.MorphologicalDataOA.ProdRestrictOA.PossibilitiesOS[3] as CmPossibility;
derivAffixMsa1.ToProdRestrictRC.Add(pr3.Hvo);
derivAffixMsa2.ToProdRestrictRC.Add(pr4.Hvo);
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to productivity restrictions differences.");
derivAffixMsa1.ToProdRestrictRC.Add(pr4.Hvo);
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to productivity restrictions count difference.");
// Match Productivity Restrictions
derivAffixMsa2.ToProdRestrictRC.Add(pr3.Hvo);
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching productivity restrictions");
// compare different FromMsFeatures
XmlDocument doc = new XmlDocument();
doc.LoadXml(m_ksFS1);
XmlNode itemNeut = doc.SelectSingleNode("/item/item[3]");
XmlNode itemFem = doc.SelectSingleNode("/item/item[2]");
derivAffixMsa1.FromMsFeaturesOA = new FsFeatStruc();
derivAffixMsa2.FromMsFeaturesOA = new FsFeatStruc();
derivAffixMsa1.FromMsFeaturesOA.AddFeatureFromXml(Cache, itemNeut);
derivAffixMsa2.FromMsFeaturesOA.AddFeatureFromXml(Cache, itemFem);
Assert.IsFalse(derivAffixMsa1.FromMsFeaturesOA.IsEquivalent(derivAffixMsa2.FromMsFeaturesOA), "FromMsFeaturesOA should not be equal.");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to different FromMsFeaturesOA.");
// match feature structures
derivAffixMsa1.FromMsFeaturesOA.AddFeatureFromXml(Cache, itemFem);
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching feature structure");
// compare different ToMsFeatures
derivAffixMsa1.ToMsFeaturesOA = new FsFeatStruc();
derivAffixMsa2.ToMsFeaturesOA = new FsFeatStruc();
derivAffixMsa1.ToMsFeaturesOA.AddFeatureFromXml(Cache, itemFem);
derivAffixMsa2.ToMsFeaturesOA.AddFeatureFromXml(Cache, itemNeut);
Assert.IsFalse(derivAffixMsa1.ToMsFeaturesOA.IsEquivalent(derivAffixMsa2.ToMsFeaturesOA), "ToMsFeaturesOA should not be equal.");
Assert.IsFalse(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 should not be equal to derivAffixMsa2 due to different ToMsFeaturesOA.");
// match feature structures
derivAffixMsa1.ToMsFeaturesOA.AddFeatureFromXml(Cache, itemNeut);
Assert.IsTrue(derivAffixMsa1.EqualsMsa(derivAffixMsa2), "derivAffixMsa1 & derivAffixMsa2 should be equal with matching feature structure");
}
public void MoUnclassifiedAffixMsa_EqualMsa()
{
CheckDisposed();
ILangProject lp = Cache.LangProject;
ILexDb ld = lp.LexDbOA;
ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
MoUnclassifiedAffixMsa unclassifiedAffixMsa1 = new MoUnclassifiedAffixMsa();
MoUnclassifiedAffixMsa unclassifiedAffixMsa2 = new MoUnclassifiedAffixMsa();
MoStemMsa stemMsa = new MoStemMsa();
MoInflAffMsa inflAffixMsa = new MoInflAffMsa();
MoDerivAffMsa derivAffixMsa = new MoDerivAffMsa();
le.MorphoSyntaxAnalysesOC.Add(unclassifiedAffixMsa1);
le.MorphoSyntaxAnalysesOC.Add(unclassifiedAffixMsa2);
le.MorphoSyntaxAnalysesOC.Add(stemMsa);
le.MorphoSyntaxAnalysesOC.Add(inflAffixMsa);
le.MorphoSyntaxAnalysesOC.Add(derivAffixMsa);
DummyGenericMSA dummyMsa1 = DummyGenericMSA.Create(unclassifiedAffixMsa1);
DummyGenericMSA dummyMsa2 = DummyGenericMSA.Create(unclassifiedAffixMsa2);
DummyGenericMSA dummyMsa3 = DummyGenericMSA.Create(stemMsa);
DummyGenericMSA dummyMsa4 = DummyGenericMSA.Create(inflAffixMsa);
DummyGenericMSA dummyMsa5 = DummyGenericMSA.Create(derivAffixMsa);
// Verify we fail comparing on different MSA types.
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(stemMsa));
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(inflAffixMsa));
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(derivAffixMsa));
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(dummyMsa3));
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(dummyMsa4));
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(dummyMsa5));
// Verify that unclassifiedAffixMsa1 equals itself.
Assert.IsTrue(unclassifiedAffixMsa1.EqualsMsa(unclassifiedAffixMsa1), unclassifiedAffixMsa1.ToString() + " - should equal itself.");
// Verify that unclassifiedAffixMsa1 equals unclassifiedAffixMsa2
Assert.IsTrue(unclassifiedAffixMsa1.EqualsMsa(unclassifiedAffixMsa2), unclassifiedAffixMsa1.ToString() + " - should equal - " + unclassifiedAffixMsa2.ToString());
Assert.IsTrue(unclassifiedAffixMsa1.EqualsMsa(dummyMsa2), "unclassifiedAffixMsa1 should equal dummyMsa2");
// compare with on different PartOfSpeech
FdoOwningSequence<ICmPossibility> posSeq = lp.PartsOfSpeechOA.PossibilitiesOS;
IPartOfSpeech pos1 = (IPartOfSpeech)posSeq.Append(new PartOfSpeech());
IPartOfSpeech pos2 = (IPartOfSpeech)posSeq.Append(new PartOfSpeech());
unclassifiedAffixMsa1.PartOfSpeechRA = pos1;
unclassifiedAffixMsa2.PartOfSpeechRA = pos2;
dummyMsa2.MainPOS = pos2.Hvo;
Assert.IsTrue(unclassifiedAffixMsa1.PartOfSpeechRA != unclassifiedAffixMsa2.PartOfSpeechRA, "msa POSes should not be equal.");
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(unclassifiedAffixMsa2), "unclassifiedAffixMsa1 should not be equal to unclassifiedAffixMsa2 due to different POS");
Assert.IsFalse(unclassifiedAffixMsa1.EqualsMsa(dummyMsa2), "unclassifiedAffixMsa1 should not equal dummyMsa2");
// reset POS
unclassifiedAffixMsa1.PartOfSpeechRAHvo = unclassifiedAffixMsa2.PartOfSpeechRAHvo;
dummyMsa2.MainPOS = unclassifiedAffixMsa1.PartOfSpeechRAHvo;
Assert.IsTrue(unclassifiedAffixMsa1.EqualsMsa(unclassifiedAffixMsa2), "unclassifiedAffixMsa1 & unclassifiedAffixMsa2 should be equal with matching POS");
Assert.IsTrue(unclassifiedAffixMsa1.EqualsMsa(dummyMsa2), "unclassifiedAffixMsa1 should equal dummyMsa2");
}
// TODO RandyR: Add ShortNameTSS and DeletionTextTSS. (DeleteUnderlyingObject() is not meeded.)
/// <summary>
/// Create other required elements.
/// </summary>
public override void InitNewInternal()
{
base.InitNewInternal();
LeftMsaOA = new MoStemMsa();
RightMsaOA = new MoStemMsa();
}
public void MoInflAffMsa_EqualMsa()
{
CheckDisposed();
CreateTestData();
ILangProject lp = Cache.LangProject;
ILexDb ld = lp.LexDbOA;
ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
MoInflAffMsa infAffixMsa1 = new MoInflAffMsa();
MoInflAffMsa infAffixMsa2 = new MoInflAffMsa();
MoStemMsa stemMsa = new MoStemMsa();
MoDerivAffMsa derivAffixMsa = new MoDerivAffMsa();
MoUnclassifiedAffixMsa unclassifiedAffixMsa = new MoUnclassifiedAffixMsa();
le.MorphoSyntaxAnalysesOC.Add(infAffixMsa1);
le.MorphoSyntaxAnalysesOC.Add(infAffixMsa2);
le.MorphoSyntaxAnalysesOC.Add(stemMsa);
le.MorphoSyntaxAnalysesOC.Add(derivAffixMsa);
le.MorphoSyntaxAnalysesOC.Add(unclassifiedAffixMsa);
DummyGenericMSA dummyMsa1 = DummyGenericMSA.Create(infAffixMsa1);
DummyGenericMSA dummyMsa2 = DummyGenericMSA.Create(infAffixMsa2);
DummyGenericMSA dummyMsa3 = DummyGenericMSA.Create(stemMsa);
DummyGenericMSA dummyMsa4 = DummyGenericMSA.Create(derivAffixMsa);
DummyGenericMSA dummyMsa5 = DummyGenericMSA.Create(unclassifiedAffixMsa);
// Verify we fail comparing on different MSA types.
Assert.IsFalse(infAffixMsa1.EqualsMsa(stemMsa));
Assert.IsFalse(infAffixMsa1.EqualsMsa(derivAffixMsa));
Assert.IsFalse(infAffixMsa1.EqualsMsa(unclassifiedAffixMsa));
Assert.IsFalse(infAffixMsa1.EqualsMsa(dummyMsa3));
Assert.IsFalse(infAffixMsa1.EqualsMsa(dummyMsa4));
Assert.IsFalse(infAffixMsa1.EqualsMsa(dummyMsa5));
// Verify that infAffixMsa1 equals itself.
Assert.IsTrue(infAffixMsa1.EqualsMsa(infAffixMsa1), infAffixMsa1.ToString() + " - should equal itself.");
// Verify that infAffixMsa1 equals infAffixMsa2
Assert.IsTrue(infAffixMsa1.EqualsMsa(infAffixMsa2), infAffixMsa1.ToString() + " - should equal - " + infAffixMsa2.ToString());
Assert.IsTrue(infAffixMsa1.EqualsMsa(dummyMsa2), "infAffixMsa1 should equal dummyMsa2");
// compare with on different PartOfSpeech
FdoOwningSequence<ICmPossibility> posSeq = lp.PartsOfSpeechOA.PossibilitiesOS;
IPartOfSpeech pos1 = (IPartOfSpeech)posSeq.Append(new PartOfSpeech());
IPartOfSpeech pos2 = (IPartOfSpeech)posSeq.Append(new PartOfSpeech());
infAffixMsa1.PartOfSpeechRA = pos1;
infAffixMsa2.PartOfSpeechRA = pos2;
dummyMsa2.MainPOS = pos2.Hvo;
Assert.IsTrue(infAffixMsa1.PartOfSpeechRA != infAffixMsa2.PartOfSpeechRA, "msa POSes should not be equal.");
Assert.IsFalse(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 should not be equal to infAffixMsa2 due to different POS");
Assert.IsFalse(infAffixMsa1.EqualsMsa(dummyMsa2), "infAffixMsa1 should not equal dummyMsa2");
// reset POS
infAffixMsa1.PartOfSpeechRAHvo = infAffixMsa2.PartOfSpeechRAHvo;
dummyMsa2.MainPOS = infAffixMsa1.PartOfSpeechRAHvo;
Assert.IsTrue(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 & infAffixMsa2 should be equal with matching POS");
Assert.IsTrue(infAffixMsa1.EqualsMsa(dummyMsa2), "infAffixMsa1 should equal dummyMsa2");
// skip AffixCategory
// compare different Slots
pos1.AffixSlotsOC.Add(new MoInflAffixSlot());
pos1.AffixSlotsOC.Add(new MoInflAffixSlot());
infAffixMsa1.SlotsRC.Add(pos1.AffixSlotsOC.HvoArray[0]);
infAffixMsa2.SlotsRC.Add(pos1.AffixSlotsOC.HvoArray[1]);
dummyMsa2.Slot = pos1.AffixSlotsOC.HvoArray[1];
Assert.IsFalse(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 should not be equal to infAffixMsa2 due to affix slots differences.");
Assert.IsFalse(infAffixMsa1.EqualsMsa(dummyMsa2), "infAffixMsa1 should not equal dummyMsa2");
infAffixMsa1.SlotsRC.Add(pos1.AffixSlotsOC.HvoArray[1]);
Assert.IsTrue(infAffixMsa1.SlotsRC.Count != infAffixMsa2.SlotsRC.Count);
Assert.IsFalse(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 should not be equal to infAffixMsa2 due to affix slots Count differences.");
Assert.IsFalse(infAffixMsa1.EqualsMsa(dummyMsa2), "infAffixMsa1 should not equal dummyMsa2");
infAffixMsa2.SlotsRC.Add(pos1.AffixSlotsOC.HvoArray[0]);
Assert.IsTrue(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 should equal infAffixMsa2 due to affix slots matching.");
// compare different FromProdRestrict
ICmPossibility pr1 = lp.MorphologicalDataOA.ProdRestrictOA.PossibilitiesOS[0];
ICmPossibility pr2 = lp.MorphologicalDataOA.ProdRestrictOA.PossibilitiesOS[1];
infAffixMsa1.FromProdRestrictRC.Add(pr1.Hvo);
infAffixMsa2.FromProdRestrictRC.Add(pr2.Hvo);
Assert.IsFalse(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 should not be equal to infAffixMsa2 due to productivity restrictions differences.");
infAffixMsa1.FromProdRestrictRC.Add(pr2.Hvo);
Assert.IsFalse(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 should not be equal to infAffixMsa2 due to productivity restrictions count difference.");
// Match Productivity Restrictions
infAffixMsa2.FromProdRestrictRC.Add(pr1.Hvo);
Assert.IsTrue(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 & infAffixMsa2 should be equal with matching productivity restrictions");
// compare different InflFeats
XmlDocument doc = new XmlDocument();
doc.LoadXml(m_ksFS1);
XmlNode itemNeut = doc.SelectSingleNode("/item/item[3]");
XmlNode itemFem = doc.SelectSingleNode("/item/item[2]");
infAffixMsa1.InflFeatsOA = new FsFeatStruc();
infAffixMsa2.InflFeatsOA = new FsFeatStruc();
infAffixMsa1.InflFeatsOA.AddFeatureFromXml(Cache, itemNeut);
infAffixMsa2.InflFeatsOA.AddFeatureFromXml(Cache, itemFem);
Assert.IsFalse(infAffixMsa1.InflFeatsOA.IsEquivalent(infAffixMsa2.InflFeatsOA), "InflFeatsOA should not be equal.");
Assert.IsFalse(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 should not be equal to infAffixMsa2 due to different InflFeatsOA.");
// match feature structures
infAffixMsa1.InflFeatsOA.AddFeatureFromXml(Cache, itemFem);
Assert.IsTrue(infAffixMsa1.EqualsMsa(infAffixMsa2), "infAffixMsa1 & infAffixMsa2 should be equal with matching feature structure");
}
public void DeleteMoMorphAdhocProhib()
{
CheckDisposed();
ILexDb ld = Cache.LangProject.LexDbOA;
ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
Assert.AreEqual(1, le.SensesOS.Count);
LexSense ls = le.SensesOS[0] as LexSense;
Assert.AreEqual(1, le.MorphoSyntaxAnalysesOC.Count);
int hvoMsa = le.MorphoSyntaxAnalysesOC.HvoArray[0];
Assert.AreEqual(hvoMsa, ls.MorphoSyntaxAnalysisRAHvo);
IMoMorphSynAnalysis baseMsa = ls.MorphoSyntaxAnalysisRA;
MoMorphAdhocProhib mmac = (MoMorphAdhocProhib)
Cache.LangProject.MorphologicalDataOA.AdhocCoProhibitionsOC.Add(new MoMorphAdhocProhib());
// Set FirstMorpheme
mmac.FirstMorphemeRA = baseMsa;
Assert.AreEqual(baseMsa.Hvo, mmac.FirstMorphemeRAHvo);
// Build Morphemes (Reference Sequence) for our mmac
int i = 0;
for (; i < 2; i++)
{
// Add new MSA to our LexEntry
MoMorphSynAnalysis msa = new MoStemMsa();
le.MorphoSyntaxAnalysesOC.Add(msa);
Assert.AreEqual(i + 2, le.MorphoSyntaxAnalysesOC.Count);
// Add new MSA to Components
mmac.MorphemesRS.Append(msa.Hvo);
Assert.AreEqual(i + 1, mmac.MorphemesRS.Count);
Assert.AreEqual(msa.Hvo, mmac.MorphemesRS[i].Hvo);
}
// Build RestOfMorphs (Reference Sequence) for our mmac
for (int j = 0; j < 2; j++)
{
// Add new MSA to our LexEntry
MoMorphSynAnalysis msa = new MoStemMsa();
le.MorphoSyntaxAnalysesOC.Add(msa);
Assert.AreEqual(j + (i + 2), le.MorphoSyntaxAnalysesOC.Count);
// Add new MSA to Components
mmac.RestOfMorphsRS.Append(msa.Hvo);
Assert.AreEqual(j + 1, mmac.RestOfMorphsRS.Count);
Assert.AreEqual(msa.Hvo, mmac.RestOfMorphsRS[j].Hvo);
}
// Delete our LexSense so that when we delete the msa, mmac can delete its FirstMorpheme.
ls.DeleteUnderlyingObject();
Assert.AreEqual(0, le.SensesOS.Count);
Assert.AreEqual(1 + 2 + 2, le.MorphoSyntaxAnalysesOC.Count);
// Delete our MoMorphAdhocProhib (mmac)
mmac.DeleteUnderlyingObject();
Assert.AreEqual(0, le.MorphoSyntaxAnalysesOC.Count);
}
/// <summary>
/// Go through the senses of this entry, ensuring that each one has an MSA assigned to it.
/// MergeRedundantMSAs() should be called after this method.
/// </summary>
public void EnsureValidMSAsForSenses()
{
bool fIsAffix = MoMorphType.IsAffixType(this.MorphType);
foreach (ILexSense ls in this.AllSenses)
{
if (ls.MorphoSyntaxAnalysisRAHvo != 0)
continue;
IMoMorphSynAnalysis msa;
if (fIsAffix)
{
msa = FindEmptyAffixMsa();
if (msa == null)
{
msa = new MoUnclassifiedAffixMsa();
this.MorphoSyntaxAnalysesOC.Add(msa);
}
}
else
{
msa = FindEmptyStemMsa();
if (msa == null)
{
msa = new MoStemMsa();
this.MorphoSyntaxAnalysesOC.Add(msa);
}
}
ls.MorphoSyntaxAnalysisRAHvo = msa.Hvo;
}
}
public void ChangeMsaOnLexSense()
{
CheckDisposed();
ILexDb ld = Cache.LangProject.LexDbOA;
ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
Assert.AreEqual(1, le.SensesOS.Count);
LexSense ls = le.SensesOS[0] as LexSense;
Assert.AreEqual(1, le.MorphoSyntaxAnalysesOC.Count);
int hvoMsa = le.MorphoSyntaxAnalysesOC.HvoArray[0];
Assert.AreEqual(hvoMsa, ls.MorphoSyntaxAnalysisRAHvo);
// Add new MSA to LexEntry
MoMorphSynAnalysis msa = new MoStemMsa();
le.MorphoSyntaxAnalysesOC.Add(msa);
Assert.AreEqual(2, le.MorphoSyntaxAnalysesOC.Count);
// Change the LexSense MSA
ls.MorphoSyntaxAnalysisRA = msa;
Assert.AreEqual(msa.Hvo, ls.MorphoSyntaxAnalysisRAHvo);
Assert.AreEqual(1, le.MorphoSyntaxAnalysesOC.Count);
Assert.AreEqual(msa.Hvo, le.MorphoSyntaxAnalysesOC.HvoArray[0]);
}
public void ChangeMsaOnWfiMorphBundle()
{
CheckDisposed();
ILexDb ld = Cache.LangProject.LexDbOA;
ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
Assert.AreEqual(1, le.SensesOS.Count);
LexSense ls = le.SensesOS[0] as LexSense;
Assert.AreEqual(1, le.MorphoSyntaxAnalysesOC.Count);
int hvoMsa = le.MorphoSyntaxAnalysesOC.HvoArray[0];
Assert.AreEqual(hvoMsa, ls.MorphoSyntaxAnalysisRAHvo);
// Setup WfiMorphBundle
IWfiWordform wf = Cache.LangProject.WordformInventoryOA.WordformsOC.Add(new WfiWordform());
IWfiAnalysis anal = wf.AnalysesOC.Add(new WfiAnalysis());
IWfiMorphBundle wmb = anal.MorphBundlesOS.Append(new WfiMorphBundle());
MoStemAllomorph bearNForm = (MoStemAllomorph)le.AlternateFormsOS.Append(new MoStemAllomorph());
bearNForm.Form.VernacularDefaultWritingSystem = "bearNTEST";
wmb.MorphRA = bearNForm;
wmb.MsaRA = ls.MorphoSyntaxAnalysisRA;
// Add new MSA to LexEntry
MoMorphSynAnalysis msa = new MoStemMsa();
le.MorphoSyntaxAnalysesOC.Add(msa);
Assert.AreEqual(2, le.MorphoSyntaxAnalysesOC.Count);
// Change LexSense MSA to new MSA
ls.MorphoSyntaxAnalysisRA = msa;
Assert.AreEqual(msa.Hvo, ls.MorphoSyntaxAnalysisRAHvo);
Assert.AreEqual(2, le.MorphoSyntaxAnalysesOC.Count);
// Change Msa on WfiMorphBundle
wmb.MsaRA = ls.MorphoSyntaxAnalysisRA;
Assert.AreEqual(msa.Hvo, wmb.MsaRA.Hvo);
Assert.AreEqual(1, le.MorphoSyntaxAnalysesOC.Count);
}
public void CheckNumberOfEntries()
{
CheckDisposed();
m_fdoCache.LangProject.LexDbOA.EntriesOC.Add(new LexEntry());
m_fdoCache.LangProject.PartsOfSpeechOA.PossibilitiesOS.Append(new PartOfSpeech());
PartOfSpeech pos = (Ling.PartOfSpeech)m_fdoCache.LangProject.PartsOfSpeechOA.PossibilitiesOS.FirstItem;
int hvoLme = m_fdoCache.LangProject.LexDbOA.EntriesOC.HvoArray[0];
ILexEntry lme = LexEntry.CreateFromDBObject(m_fdoCache, hvoLme);
int cRef1 = pos.NumberOfLexEntries;
MoStemMsa msm = new MoStemMsa();
lme.MorphoSyntaxAnalysesOC.Add(msm);
msm.PartOfSpeechRA = pos;
int cRef2 = pos.NumberOfLexEntries;
Assert.IsTrue(cRef1 + 1 == cRef2, "NumberOfLexEntries for MoStemMsa was " +
cRef2 + " but should have been" + (cRef1 + 1));
MoMorphType mmt = (Ling.MoMorphType)m_fdoCache.LangProject.LexDbOA.MorphTypesOA.PossibilitiesOS.FirstItem;
cRef1 = mmt.NumberOfLexEntries;
MoStemAllomorph msa = new MoStemAllomorph();
lme.AlternateFormsOS.Append(msa);
msa.MorphTypeRA = mmt;
cRef2 = mmt.NumberOfLexEntries;
Assert.IsTrue(cRef1 + 1 == cRef2, "NumberOfLexEntries for MoMorphType was " +
cRef2 + " but should have been" + (cRef1 + 1));
}
public void InflectionClassInCompoundStemMsasIsRelevant()
{
CheckDisposed();
MoExoCompound compound = new MoExoCompound();
Cache.LangProject.MorphologicalDataOA.CompoundRulesOS.Append(compound);
MoStemMsa msaLeft = new MoStemMsa();
MoStemMsa msaRight = new MoStemMsa();
MoStemMsa msaTo = new MoStemMsa();
compound.LeftMsaOA = msaLeft;
compound.RightMsaOA = msaRight;
compound.ToMsaOA = msaTo;
Assert.IsFalse(msaLeft.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidInflectionClass),
"Inflection Class should not be relevant for LeftMsa.");
Assert.IsFalse(msaRight.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidInflectionClass),
"Inflection Class should not be relevant for RightMsa.");
Assert.IsFalse(msaTo.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidInflectionClass),
"Inflection Class should not be relevant for ToMsa if it does not have a category.");
PartOfSpeech pos = new PartOfSpeech();
Cache.LangProject.PartsOfSpeechOA.PossibilitiesOS.Append(pos);
msaTo.PartOfSpeechRA = pos;
Assert.IsTrue(msaTo.IsFieldRelevant((int)MoStemMsa.MoStemMsaTags.kflidInflectionClass),
"Inflection Class should be relevant for ToMsa when it has a category.");
}
// TODO RandyR: Add ShortNameTSS and DeletionTextTSS.
// NOTE: Don't override ShortName here, as the superclass override will do it right.
///<summary>
/// Copies attributes associated with the current POS, such as inflection features and classes, that
/// are valid from the specified MSA to this MSA. If the attribute is not valid, it is removed from
/// this MSA.
///</summary>
///<param name="srcMsa">the source MSA</param>
public void CopyAttributesIfValid(MoStemMsa srcMsa)
{
// inflection classes
if (IsReferenceAttributeValid(srcMsa.InflectionClassRAHvo, (int)MoStemMsaTags.kflidInflectionClass))
{
if (srcMsa.InflectionClassRAHvo != InflectionClassRAHvo)
InflectionClassRAHvo = srcMsa.InflectionClassRAHvo;
}
else if (InflectionClassRAHvo != 0)
{
InflectionClassRAHvo = 0;
}
// inflection features
if (srcMsa.MsFeaturesOAHvo == 0)
{
MsFeaturesOA = null;
}
else
{
if (MsFeaturesOAHvo != srcMsa.MsFeaturesOAHvo)
m_cache.CopyObject(srcMsa.MsFeaturesOAHvo, m_hvo, (int)MoStemMsaTags.kflidMsFeatures);
RemoveInvalidFeatureSpecs(PartOfSpeechRA, MsFeaturesOA);
if (MsFeaturesOA.IsEmpty)
MsFeaturesOA = null;
}
}
/// <summary>
/// Execute the change requested by the current selection in the combo.
/// Basically we want a copy of the FsFeatStruc indicated by m_selectedHvo, (even if 0?? not yet possible),
/// to become the MsFeatures of each record that is appropriate to change.
/// We do nothing to records where the check box is turned off,
/// and nothing to ones that currently have an MSA other than an MoStemMsa,
/// and nothing to ones that currently have an MSA with the wrong POS.
/// (a) If the owning entry has an MoStemMsa with a matching MsFeatures (and presumably POS),
/// set the sense to use it.
/// (b) If all senses using the current MoStemMsa are to be changed, just update
/// the MsFeatures of that MoStemMsa.
/// We could add this...but very probably unused MSAs would have been taken over
/// when setting the POS.
/// --(c) If the entry has an MoStemMsa which is not being used at all, change it to
/// --the required POS and inflection class and use it.
/// (d) Make a new MoStemMsa in the LexEntry with the required POS and features
/// and point the sense at it.
/// </summary>
public void DoIt(Set<int> itemsToChange, ProgressState state)
{
CheckDisposed();
int hvoPos = GetPOS();
// Make a Set of eligible parts of speech to use in filtering.
Set<int> possiblePOS = GetPossiblePartsOfSpeech();
// Make a Dictionary from HVO of entry to list of modified senses.
Dictionary<int, Set<ILexSense>> sensesByEntry = new Dictionary<int, Set<ILexSense>>();
int tagOwningEntry = m_cache.VwCacheDaAccessor.GetVirtualHandlerName("LexSense", "OwningEntry").Tag;
int i = 0;
// Report progress 50 times or every 100 items, whichever is more (but no more than once per item!)
int interval = Math.Min(100, Math.Max(itemsToChange.Count / 50, 1));
foreach(int hvoSense in itemsToChange)
{
i++;
if (i % interval == 0)
{
state.PercentDone = i * 20 / itemsToChange.Count;
state.Breath();
}
if (!IsItemEligible(m_cache.MainCacheAccessor, hvoSense, possiblePOS))
continue;
ILexSense ls = (ILexSense)CmObject.CreateFromDBObject(m_cache, hvoSense, false);
IMoMorphSynAnalysis msa = ls.MorphoSyntaxAnalysisRA;
int hvoEntry = m_cache.MainCacheAccessor.get_ObjectProp(ls.Hvo, tagOwningEntry);
if (!sensesByEntry.ContainsKey(hvoEntry))
sensesByEntry[hvoEntry] = new Set<ILexSense>();
sensesByEntry[hvoEntry].Add(ls);
}
//REVIEW: Should these really be the same Undo/Redo strings as for InflectionClassEditor.cs?
m_cache.BeginUndoTask(FdoUiStrings.ksUndoBEInflClass, FdoUiStrings.ksRedoBEInflClass);
BulkEditBar.ForceRefreshOnUndoRedo(Cache.MainCacheAccessor);
i = 0;
interval = Math.Min(100, Math.Max(sensesByEntry.Count / 50, 1));
IFsFeatStruc fsTarget = null;
if (m_selectedHvo != 0)
fsTarget = FsFeatStruc.CreateFromDBObject(Cache, m_selectedHvo);
foreach (KeyValuePair<int, Set<ILexSense>> kvp in sensesByEntry)
{
i++;
if (i % interval == 0)
{
state.PercentDone = i * 80 / sensesByEntry.Count + 20;
state.Breath();
}
ILexEntry entry = (ILexEntry)CmObject.CreateFromDBObject(m_cache, kvp.Key, false);
Set<ILexSense> sensesToChange = kvp.Value;
IMoStemMsa msmTarget = null;
foreach (IMoMorphSynAnalysis msa in entry.MorphoSyntaxAnalysesOC)
{
IMoStemMsa msm = msa as IMoStemMsa;
if (msm != null && MsaMatchesTarget(msm, fsTarget))
{
// Can reuse this one!
msmTarget = msm;
break;
}
}
if (msmTarget == null)
{
// See if we can reuse an existing MoStemMsa by changing it.
// This is possible if it is used only by senses in the list, or not used at all.
Set<ILexSense> otherSenses = new Set<ILexSense>();
Set<ILexSense> senses = new Set<ILexSense>(entry.AllSenses.ToArray());
if (senses.Count != sensesToChange.Count)
{
foreach (ILexSense ls in senses)
{
if (!sensesToChange.Contains(ls))
otherSenses.Add(ls);
}
}
foreach (IMoMorphSynAnalysis msa in entry.MorphoSyntaxAnalysesOC)
{
IMoStemMsa msm = msa as IMoStemMsa;
if (msm == null)
continue;
bool fOk = true;
foreach (ILexSense ls in otherSenses)
{
if (ls.MorphoSyntaxAnalysisRA == msm)
{
fOk = false;
break;
}
}
if (fOk)
{
// Can reuse this one! Nothing we don't want to change uses it.
// Adjust its POS as well as its inflection feature, just to be sure.
// Ensure that we don't change the POS! See LT-6835.
msmTarget = msm;
InitMsa(msmTarget, msm.PartOfSpeechRAHvo);
break;
}
}
}
if (msmTarget == null)
{
// Nothing we can reuse...make a new one.
msmTarget = new MoStemMsa();
entry.MorphoSyntaxAnalysesOC.Add(msmTarget);
InitMsa(msmTarget, hvoPos);
}
// Finally! Make the senses we want to change use it.
foreach (ILexSense ls in sensesToChange)
{
ls.MorphoSyntaxAnalysisRA = msmTarget;
}
}
m_cache.EndUndoTask();
}
public void DeleteMoMorphSynAnalysis()
{
CheckDisposed();
ILexDb ld = Cache.LangProject.LexDbOA;
ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
Assert.AreEqual(1, le.SensesOS.Count);
LexSense ls = le.SensesOS[0] as LexSense;
Assert.AreEqual(1, le.MorphoSyntaxAnalysesOC.Count);
int hvoMsa = le.MorphoSyntaxAnalysesOC.HvoArray[0];
Assert.AreEqual(hvoMsa, ls.MorphoSyntaxAnalysisRAHvo);
IMoMorphSynAnalysis baseMsa = ls.MorphoSyntaxAnalysisRA;
// Build Components (Reference Sequence) for our baseMSA
for (int i = 1; i < 4; i++)
{
// Add new MSA to our LexEntry
MoMorphSynAnalysis msa = new MoStemMsa();
le.MorphoSyntaxAnalysesOC.Add(msa);
Assert.AreEqual(i + 1, le.MorphoSyntaxAnalysesOC.Count);
// Add new MSA to Components
baseMsa.ComponentsRS.Append(msa.Hvo);
Assert.AreEqual(i, baseMsa.ComponentsRS.Count);
Assert.AreEqual(msa.Hvo, baseMsa.ComponentsRS[i - 1].Hvo);
}
// Delete baseMsa by deleting the only reference to it (LexSense)
ls.DeleteUnderlyingObject();
Assert.AreEqual(0, le.SensesOS.Count);
Assert.AreEqual(0, le.MorphoSyntaxAnalysesOC.Count);
}
/// <summary>
/// Get the HVO for an appropriate default MoMorphSynAnalysis belonging to this
/// entry, creating it if necessary.
/// </summary>
/// <returns></returns>
public int FindOrCreateDefaultMsa()
{
// Search for an appropriate MSA already existing for the LexEntry.
foreach (IMoMorphSynAnalysis msa in this.MorphoSyntaxAnalysesOC)
{
if (MoMorphType.IsAffixType(this.MorphType))
{
if (msa is MoUnclassifiedAffixMsa)
return msa.Hvo;
}
else
{
if (msa is MoStemMsa)
return msa.Hvo;
}
}
// Nothing exists, create the needed MSA.
MoMorphSynAnalysis msaNew;
if (MoMorphType.IsAffixType(MorphType))
msaNew = new MoUnclassifiedAffixMsa();
else
msaNew = new MoStemMsa();
msaNew.InitNew(this.Cache, this.Hvo, this.MorphoSyntaxAnalysesOC.Flid, 0);
MorphoSyntaxAnalysesOC.Add(msaNew);
return msaNew.Hvo;
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="ld"></param>
/// <param name="cf"></param>
/// <param name="defn"></param>
/// <param name="hvoDomain"></param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
protected ILexEntry MakeLexEntry(ILexDb ld, string cf, string defn, int hvoDomain)
{
ILexEntry le = ld.EntriesOC.Add(new LexEntry());
le.CitationForm.VernacularDefaultWritingSystem = cf;
ILexSense ls = le.SensesOS.Append(new LexSense());
ls.Definition.AnalysisDefaultWritingSystem.Text = defn;
if (hvoDomain != 0)
ls.SemanticDomainsRC.Add(hvoDomain);
MoMorphSynAnalysis msa = new MoStemMsa();
le.MorphoSyntaxAnalysesOC.Add(msa);
ls.MorphoSyntaxAnalysisRA = msa;
return le;
}
private int FindOrCreateMatchingStemMsa(IMoMorphSynAnalysis msa)
{
int hvoPOS = 0;
if (msa is IMoInflAffMsa)
hvoPOS = (msa as IMoInflAffMsa).PartOfSpeechRAHvo;
else if (msa is IMoDerivAffMsa)
hvoPOS = (msa as IMoDerivAffMsa).ToPartOfSpeechRAHvo;
else if (msa is IMoDerivStepMsa)
hvoPOS = (msa as IMoDerivStepMsa).PartOfSpeechRAHvo;
else if (msa is IMoUnclassifiedAffixMsa)
hvoPOS = (msa as IMoUnclassifiedAffixMsa).PartOfSpeechRAHvo;
foreach (IMoMorphSynAnalysis msaT in this.MorphoSyntaxAnalysesOC)
{
IMoStemMsa msaStem = msaT as IMoStemMsa;
if (msaStem != null &&
msaStem.PartOfSpeechRAHvo == hvoPOS &&
msaStem.FromPartsOfSpeechRC.Count == 0 &&
msaStem.InflectionClassRAHvo == 0 &&
msaStem.ProdRestrictRC.Count == 0 &&
msaStem.StratumRAHvo == 0 &&
msaStem.MsFeaturesOAHvo == 0)
{
return msaStem.Hvo;
}
}
IMoStemMsa msaNew = new MoStemMsa();
this.MorphoSyntaxAnalysesOC.Add(msaNew);
msaNew.PartOfSpeechRAHvo = hvoPOS;
return msaNew.Hvo;
}
// TODO RandyR: Add ShortNameTSS and DeletionTextTSS. (DeleteUnderlyingObject() is not meeded.)
/// <summary>
/// Create other required elements.
/// </summary>
public override void InitNewInternal()
{
base.InitNewInternal();
ToMsaOA = new MoStemMsa();
}
