private void BuildPhraseLayersOf(PhraseBuilder phraseBuilder, UnifiedNode phraseResult)
{
phraseBuilder.DiscourseFunctionSpecified = phraseResult.DiscourseFunction != null;
if (phraseBuilder.DiscourseFunctionSpecified)
{
phraseBuilder.DiscourseFunction = (discourseFunction)phraseResult.DiscourseFunction;
}
phraseBuilder.AppositiveSpecified = phraseResult.Appositive != null;
if (phraseBuilder.AppositiveSpecified)
{
phraseBuilder.Appositive = (bool)phraseResult.Appositive;
}
switch (phraseBuilder)
{
case NounPhraseBuilder nounPhrase:
BuildNounPhraseLayerOf(nounPhrase, phraseResult);
break;
case VerbPhraseBuilder verbPhrase:
BuildVerbPhraseLayerOf(verbPhrase, phraseResult);
break;
case AdjectivePhraseBuilder adjectivePhrase:
BuildAdjectivePhraseLayerOf(adjectivePhrase, phraseResult);
break;
case AdverbPhraseBuilder adverbPhrase:
BuildAdverbPhraseLayerOf(adverbPhrase, phraseResult);
break;
}
}
private void BuildWordLayersOf(WordElementBuilder wordBuilder, UnifiedNode wordResult)
{
wordBuilder.ExpletiveSubjectSpecified = wordResult.ExpletiveSubject != null;
if (wordBuilder.ExpletiveSubjectSpecified)
{
wordBuilder.ExpletiveSubject = (bool)wordResult.ExpletiveSubject;
}
wordBuilder.ProperSpecified = wordResult.Proper != null;
if (wordBuilder.ProperSpecified)
{
wordBuilder.Proper = (bool)wordResult.Proper;
}
wordBuilder.InflectionSpecified = wordResult.Inflection != null;
if (wordBuilder.InflectionSpecified)
{
wordBuilder.Inflection = (inflection)wordResult.Inflection;
}
wordBuilder.CannedSpecified = wordResult.Canned != null;
if (wordBuilder.CannedSpecified)
{
wordBuilder.Canned = (bool)wordResult.Canned;
}
switch (wordBuilder)
{
case PronounBuilder pronounBuilder:
BuildPronounLayerOf(pronounBuilder, wordResult);
break;
}
}
private void BuildClauseLayerOf(ClauseBuilder clauseBuilder, UnifiedNode clauseResult)
{
clauseBuilder.AggregateAuxiliarySpecified = clauseResult.C_AggregateAuxiliary != null;
if (clauseBuilder.AggregateAuxiliarySpecified)
{
clauseBuilder.AggregateAuxiliary = (bool)clauseResult.C_AggregateAuxiliary;
}
clauseBuilder.Complementiser = clauseResult.C_Complementizer;
clauseBuilder.FormSpecified = clauseResult.C_Form != null;
if (clauseBuilder.FormSpecified)
{
clauseBuilder.Form = (form)clauseResult.C_Form;
}
clauseBuilder.InterrogativeTypeSpecified = clauseResult.C_InterrogativeType != null;
if (clauseBuilder.InterrogativeTypeSpecified)
{
clauseBuilder.InterrogativeType = (interrogativeType)clauseResult.C_InterrogativeType;
}
clauseBuilder.Modal = clauseResult.C_Modal;
clauseBuilder.NegatedSpecified = clauseResult.C_Negated != null;
if (clauseBuilder.NegatedSpecified)
{
clauseBuilder.Negated = (bool)clauseResult.C_Negated;
}
clauseBuilder.PassiveSpecified = clauseResult.C_Passive != null;
if (clauseBuilder.PassiveSpecified)
{
clauseBuilder.Passive = (bool)clauseResult.C_Passive;
}
clauseBuilder.PerfectSpecified = clauseResult.C_Perfect != null;
if (clauseBuilder.PerfectSpecified)
{
clauseBuilder.Perfect = (bool)clauseResult.C_Perfect;
}
clauseBuilder.PersonSpecified = clauseResult.C_Person != null;
if (clauseBuilder.PersonSpecified)
{
clauseBuilder.Person = (person)clauseResult.C_Person;
}
clauseBuilder.ProgressiveSpecified = clauseResult.C_Progressive != null;
if (clauseBuilder.ProgressiveSpecified)
{
clauseBuilder.Progressive = (bool)clauseResult.C_Progressive;
}
clauseBuilder.SuppressGenitiveInGerundSpecified = clauseResult.C_SuppressGenitiveInGerund != null;
if (clauseBuilder.SuppressGenitiveInGerundSpecified)
{
clauseBuilder.SuppressGenitiveInGerund = (bool)clauseResult.C_SuppressGenitiveInGerund;
}
clauseBuilder.SuppressedComplementiserSpecified = clauseResult.C_SuppressedComplementizer != null;
if (clauseBuilder.SuppressedComplementiserSpecified)
{
clauseBuilder.SuppressedComplementiser = (bool)clauseResult.C_SuppressedComplementizer;
}
clauseBuilder.TenseSpecified = clauseResult.C_Tense != null;
if (clauseBuilder.TenseSpecified)
{
clauseBuilder.Tense = (tense)clauseResult.C_Tense;
}
}
private void BuildParentLayersOf(ParentElementBuilder parentBuilder, UnifiedNode parentResult)
{
switch (parentBuilder)
{
case IndependentClauseBuilder clauseBuilder:
BuildPhraseLayersOf(clauseBuilder, parentResult);
break;
case SubordinateClauseBuilder clauseBuilder:
BuildPhraseLayersOf(clauseBuilder, parentResult);
break;
case NounPhraseBuilder nounPhraseBuilder:
BuildPhraseLayersOf(nounPhraseBuilder, parentResult);
break;
case VerbPhraseBuilder verbPhraseBuilder:
BuildPhraseLayersOf(verbPhraseBuilder, parentResult);
break;
case AdjectivePhraseBuilder adjectivePhraseBuilder:
BuildPhraseLayersOf(adjectivePhraseBuilder, parentResult);
break;
case AdverbPhraseBuilder adverbPhraseBuilder:
BuildPhraseLayersOf(adverbPhraseBuilder, parentResult);
break;
case PrepositionalPhraseBuilder prepositionalPhraseBuilder:
BuildPhraseLayersOf(prepositionalPhraseBuilder, parentResult);
break;
}
}
private ParentElementBuilder BuildParent(UnifiedNode parentResult, IEnumerable <UnifiedNode> nodeResults, IEnumerable <GetWeightedWordsForTreeResult> weightedWordResults, List <GetChildOrderingsForTreeResult> childOrderingResults)
{
ParentElementBuilder parentBuilder = FlexData.Parent.BuilderOfType((FlexData.ParentType)parentResult.ParentType);
parentBuilder.FlexDB_ID = (int)parentResult.ID;
BuildParentLayersOf(parentBuilder, parentResult);
BuildChildrenOf(parentBuilder, nodeResults, weightedWordResults, childOrderingResults);
return(parentBuilder);
}
private IElementTreeNode BuildTreeNode(int nodeID, IEnumerable <UnifiedNode> nodeResults, IEnumerable <GetWeightedWordsForTreeResult> weightedWordResults, List <GetChildOrderingsForTreeResult> childOrderingResults)
{
UnifiedNode resultForThisNode = nodeResults.Single(result => result.ID.Equals(nodeID));
return((FlexData.ElementType)resultForThisNode.ElementType switch
{
FlexData.ElementType.DB_Word => BuildWord(resultForThisNode, weightedWordResults.Where(weightedWord => weightedWord.WordElement.Equals(resultForThisNode.ID))),
FlexData.ElementType.DB_Parent => BuildParent(resultForThisNode, nodeResults, weightedWordResults, childOrderingResults),
_ => throw new InvalidOperationException("Invalid FlexData.ElementType")
});
private void BuildVerbPhraseLayerOf(VerbPhraseBuilder verbPhraseBuilder, UnifiedNode phraseResult)
{
verbPhraseBuilder.AggregateAuxiliarySpecified = phraseResult.VP_AggregateAuxiliary != null;
if (verbPhraseBuilder.AggregateAuxiliarySpecified)
{
verbPhraseBuilder.AggregateAuxiliary = (bool)phraseResult.VP_AggregateAuxiliary;
}
verbPhraseBuilder.FormSpecified = phraseResult.VP_Form != null;
if (verbPhraseBuilder.FormSpecified)
{
verbPhraseBuilder.Form = (form)phraseResult.VP_Form;
}
verbPhraseBuilder.Modal = phraseResult.VP_Modal;
verbPhraseBuilder.NegatedSpecified = phraseResult.VP_Negated != null;
if (verbPhraseBuilder.NegatedSpecified)
{
verbPhraseBuilder.Negated = (bool)phraseResult.VP_Negated;
}
verbPhraseBuilder.PassiveSpecified = phraseResult.VP_Passive != null;
if (verbPhraseBuilder.PassiveSpecified)
{
verbPhraseBuilder.Passive = (bool)phraseResult.VP_Passive;
}
verbPhraseBuilder.PerfectSpecified = phraseResult.VP_Perfect != null;
if (verbPhraseBuilder.PerfectSpecified)
{
verbPhraseBuilder.Perfect = (bool)phraseResult.VP_Perfect;
}
verbPhraseBuilder.PersonSpecified = phraseResult.VP_Person != null;
if (verbPhraseBuilder.PersonSpecified)
{
verbPhraseBuilder.Person = (person)phraseResult.VP_Person;
}
verbPhraseBuilder.ProgressiveSpecified = phraseResult.VP_Progressive != null;
if (verbPhraseBuilder.ProgressiveSpecified)
{
verbPhraseBuilder.Progressive = (bool)phraseResult.VP_Progressive;
}
verbPhraseBuilder.SuppressGenitiveInGerundSpecified = phraseResult.VP_SuppressGenitiveInGerund != null;
if (verbPhraseBuilder.SuppressGenitiveInGerundSpecified)
{
verbPhraseBuilder.SuppressGenitiveInGerund = (bool)phraseResult.VP_SuppressGenitiveInGerund;
}
verbPhraseBuilder.SuppressedComplementiserSpecified = phraseResult.VP_SuppressedComplementizer != null;
if (verbPhraseBuilder.SuppressedComplementiserSpecified)
{
verbPhraseBuilder.SuppressedComplementiser = (bool)phraseResult.VP_SuppressedComplementizer;
}
verbPhraseBuilder.TenseSpecified = phraseResult.VP_Tense != null;
if (verbPhraseBuilder.TenseSpecified)
{
verbPhraseBuilder.Tense = (tense)phraseResult.VP_Tense;
}
}
private void BuildPhraseLayersOf(ClauseBuilder clauseBuilder, UnifiedNode clauseResult)
{
clauseBuilder.DiscourseFunctionSpecified = clauseResult.DiscourseFunction != null;
if (clauseBuilder.DiscourseFunctionSpecified)
{
clauseBuilder.DiscourseFunction = (discourseFunction)clauseResult.DiscourseFunction;
}
clauseBuilder.AppositiveSpecified = clauseResult.Appositive != null;
if (clauseBuilder.AppositiveSpecified)
{
clauseBuilder.Appositive = (bool)clauseResult.Appositive;
}
BuildClauseLayerOf(clauseBuilder, clauseResult);
}
private WordElementBuilder BuildWord(UnifiedNode wordResult, IEnumerable <GetWeightedWordsForTreeResult> weightedWordResultsForThisBuilder)
{
WordElementBuilder wordBuilder = FlexData.Word.BuilderOfType((FlexData.WordType)wordResult.WordType);
wordBuilder.FlexDB_ID = (int)wordResult.ID;
BuildWordLayersOf(wordBuilder, wordResult);
if (weightedWordResultsForThisBuilder.Count().Equals(1))
{
wordBuilder.WordSource = new SingleWordSource(weightedWordResultsForThisBuilder.Single().Text);
}
else
{
GetWeightedWordsForTreeResult defaultWeightedWordResult = weightedWordResultsForThisBuilder.Single(weightedWordResult => wordResult.DefaultWeightedWord.Equals(weightedWordResult.ID));
WeightedWord defaultWeightedWord = new WeightedWord(defaultWeightedWordResult.Text, defaultWeightedWordResult.Weight);
IEnumerable <WeightedWord> alternateWeightedWords = weightedWordResultsForThisBuilder
.Where(weightedWordResult => weightedWordResult != defaultWeightedWordResult)
.Select(weightedWordResult => new WeightedWord(weightedWordResult.Text, weightedWordResult.Weight));
wordBuilder.WordSource = new WordSelector(defaultWeightedWord, alternateWeightedWords);
}
return(wordBuilder);
}
private void BuildNounPhraseLayerOf(NounPhraseBuilder nounPhraseBuilder, UnifiedNode phraseResult)
{
nounPhraseBuilder.AdjectiveOrderingSpecified = phraseResult.NP_AdjectiveOrdering != null;
if (nounPhraseBuilder.AdjectiveOrderingSpecified)
{
nounPhraseBuilder.AdjectiveOrdering = (bool)phraseResult.NP_AdjectiveOrdering;
}
nounPhraseBuilder.ElidedSpecified = phraseResult.NP_Elided != null;
if (nounPhraseBuilder.ElidedSpecified)
{
nounPhraseBuilder.Elided = (bool)phraseResult.NP_Elided;
}
nounPhraseBuilder.NumberSpecified = phraseResult.NP_Number != null;
if (nounPhraseBuilder.NumberSpecified)
{
nounPhraseBuilder.Number = (numberAgreement)phraseResult.NP_Number;
}
nounPhraseBuilder.GenderSpecified = phraseResult.NP_Gender != null;
if (nounPhraseBuilder.GenderSpecified)
{
nounPhraseBuilder.Gender = (gender)phraseResult.NP_Gender;
}
nounPhraseBuilder.PersonSpecified = phraseResult.NP_Person != null;
if (nounPhraseBuilder.PersonSpecified)
{
nounPhraseBuilder.Person = (person)phraseResult.NP_Person;
}
nounPhraseBuilder.PossessiveSpecified = phraseResult.NP_Possessive != null;
if (nounPhraseBuilder.PossessiveSpecified)
{
nounPhraseBuilder.Possessive = (bool)phraseResult.NP_Possessive;
}
nounPhraseBuilder.PronominalSpecified = phraseResult.NP_Pronominal != null;
if (nounPhraseBuilder.PronominalSpecified)
{
nounPhraseBuilder.Pronominal = (bool)phraseResult.NP_Pronominal;
}
}
private void BuildPronounLayerOf(PronounBuilder pronounBuilder, UnifiedNode pronounResult)
{
pronounBuilder.CaseSpecified = pronounResult.PronounCase != null;
if (pronounBuilder.CaseSpecified)
{
pronounBuilder.Case = (PronounCase)pronounResult.PronounCase;
}
pronounBuilder.PersonSpecified = pronounResult.Pronoun_Person != null;
if (pronounBuilder.PersonSpecified)
{
pronounBuilder.Person = (person)pronounResult.Pronoun_Person;
}
pronounBuilder.NumberSpecified = pronounResult.Pronoun_Number != null;
if (pronounBuilder.NumberSpecified)
{
pronounBuilder.Number = (numberAgreement)pronounResult.Pronoun_Number;
}
pronounBuilder.GenderSpecified = pronounResult.Pronoun_Gender != null;
if (pronounBuilder.GenderSpecified)
{
pronounBuilder.Gender = (gender)pronounResult.Pronoun_Gender;
}
}
private void BuildAdverbPhraseLayerOf(AdverbPhraseBuilder adverbPhraseBuilder, UnifiedNode phraseResult)
{
adverbPhraseBuilder.ComparativeSpecified = phraseResult.AdvP_Comparative != null;
if (adverbPhraseBuilder.ComparativeSpecified)
{
adverbPhraseBuilder.Comparative = (bool)phraseResult.AdvP_Comparative;
}
adverbPhraseBuilder.SuperlativeSpecified = phraseResult.AdvP_Superlative != null;
if (adverbPhraseBuilder.SuperlativeSpecified)
{
adverbPhraseBuilder.Superlative = (bool)phraseResult.AdvP_Superlative;
}
}
