/**
* Determines the minimim position at which this modifier can occur.
*
* @param modifier
* the modifier to be checked.
* @return the minimum position for this modifier.
*/
private static int getMinPos(NLGElement modifier)
{
int position = QUALITATIVE_POSITION;
if (modifier.isA(new LexicalCategory(LexicalCategory.LexicalCategoryEnum.NOUN)) || modifier.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE)))
{
position = NOUN_POSITION;
}
else if (modifier.isA(new LexicalCategory(LexicalCategory.LexicalCategoryEnum.ADJECTIVE)) || modifier.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.ADJECTIVE_PHRASE)))
{
WordElement adjective = getHeadWordElement(modifier);
if (adjective.getFeatureAsBoolean(LexicalFeature.QUALITATIVE))
{
position = QUALITATIVE_POSITION;
}
else if (adjective.getFeatureAsBoolean(LexicalFeature.COLOUR))
{
position = COLOUR_POSITION;
}
else if (adjective.getFeatureAsBoolean(LexicalFeature.CLASSIFYING))
{
position = CLASSIFYING_POSITION;
}
}
return(position);
}
/**
* Determines the number agreement for the phrase ensuring that any number
* agreement on the parent element is inherited by the phrase.
*
* @param parent
* the parent element of the phrase.
* @param phrase
* the <code>PhraseElement</code> representing this noun phrase.
* @return the <code>NumberAgreement</code> to be used for the phrase.
*/
private static NumberAgreement?determineNumber(NLGElement parent, PhraseElement phrase)
{
object numberValue = phrase.getFeature(Feature.NUMBER);
NumberAgreement?number = null;
if (numberValue != null && numberValue is NumberAgreement)
{
number = (NumberAgreement)numberValue;
}
else
{
number = NumberAgreement.SINGULAR;
}
// Ehud Reiter = modified below to force number from VP for WHAT_SUBJECT
// and WHO_SUBJECT interrogatuves
if (parent is PhraseElement)
{
if (parent.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.CLAUSE)) && (PhraseHelper.isExpletiveSubject((PhraseElement)parent) || InterrogativeType.WHO_SUBJECT.Equals(parent.getFeature(Feature.INTERROGATIVE_TYPE)) || InterrogativeType.WHAT_SUBJECT.Equals(parent.getFeature(Feature.INTERROGATIVE_TYPE))) && isCopular(phrase.getHead()))
{
if (hasPluralComplement(phrase.getFeatureAsElementList(InternalFeature.COMPLEMENTS)))
{
number = NumberAgreement.PLURAL;
}
else
{
number = NumberAgreement.SINGULAR;
}
}
}
return(number);
}
public virtual void testPronounArguments()
{
// the subject of s2 should have been cast into a pronominal NP
NLGElement subj = s2.getFeatureAsElementList(InternalFeature.SUBJECTS)[0];
Assert.IsTrue(subj.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE)));
// Assert.assertTrue(LexicalCategory.PRONOUN.equals(((PhraseElement) subj).getCategory()));
}
/**
* Determines if the given phrase has an expletive as a subject.
*
* @param phrase
* the <code>PhraseElement</code> to be examined.
* @return <code>true</code> if the phrase has an expletive subject.
*/
public static bool isExpletiveSubject(PhraseElement phrase)
{
IList <NLGElement> subjects = phrase.getFeatureAsElementList(InternalFeature.SUBJECTS);
bool expletive = false;
if (subjects.Count == 1)
{
NLGElement subjectNP = subjects[0];
if (subjectNP.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE)))
{
expletive = subjectNP.getFeatureAsBoolean(LexicalFeature.EXPLETIVE_SUBJECT);
}
else if (subjectNP.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.CANNED_TEXT)))
{
expletive = "there".Equals(subjectNP.Realisation, StringComparison.OrdinalIgnoreCase); //$NON-NLS-1$
}
}
return(expletive);
}
/**
* Realises the specifier of the noun phrase.
*
* @param phrase
* the <code>PhraseElement</code> representing this noun phrase.
* @param parent
* the parent <code>SyntaxProcessor</code> that will do the
* realisation of the complementiser.
* @param realisedElement
* the current realisation of the noun phrase.
*/
private static void realiseSpecifier(PhraseElement phrase, SyntaxProcessor parent, ListElement realisedElement)
{
NLGElement specifierElement = phrase.getFeatureAsElement(InternalFeature.SPECIFIER);
if (specifierElement != null && !phrase.getFeatureAsBoolean(InternalFeature.RAISED) && !phrase.getFeatureAsBoolean(Feature.ELIDED))
{
if (!specifierElement.isA(new LexicalCategory(LexicalCategory.LexicalCategoryEnum.PRONOUN)) && specifierElement.Category != PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE)
{
specifierElement.setFeature(Feature.NUMBER, phrase.getFeature(Feature.NUMBER));
}
NLGElement currentElement = parent.realise(specifierElement);
if (currentElement != null)
{
currentElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.SPECIFIER);
realisedElement.addComponent(currentElement);
}
}
}
/**
* Checks to see if any of the complements to the phrase are plural.
*
* @param complements
* the list of complements of the phrase.
* @return <code>true</code> if any of the complements are plural.
*/
private static bool hasPluralComplement(IList <NLGElement> complements)
{
bool plural = false;
IEnumerator <NLGElement> complementIterator = complements.GetEnumerator();
NLGElement eachComplement = null;
object numberValue = null;
while (complementIterator.MoveNext() && !plural)
{
eachComplement = complementIterator.Current;
if (eachComplement != null && eachComplement.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE)))
{
numberValue = eachComplement.getFeature(Feature.NUMBER);
if (numberValue != null && NumberAgreement.PLURAL.Equals(numberValue))
{
plural = true;
}
}
}
return(plural);
}
/**
* The main method for realising coordinated phrases.
*
* @param parent
* the <code>SyntaxProcessor</code> that called this method.
* @param phrase
* the <code>CoordinatedPhrase</code> to be realised.
* @return the realised <code>NLGElement</code>.
*/
internal static NLGElement realise(SyntaxProcessor parent, CoordinatedPhraseElement phrase)
{
ListElement realisedElement = null;
if (phrase != null)
{
realisedElement = new ListElement();
PhraseHelper.realiseList(parent, realisedElement, phrase.PreModifiers, DiscourseFunction.PRE_MODIFIER);
CoordinatedPhraseElement coordinated = new CoordinatedPhraseElement();
IList <NLGElement> children = phrase.Children;
string conjunction = phrase.getFeatureAsString(Feature.CONJUNCTION);
coordinated.setFeature(Feature.CONJUNCTION, conjunction);
coordinated.setFeature(Feature.CONJUNCTION_TYPE, phrase.getFeature(Feature.CONJUNCTION_TYPE));
InflectedWordElement conjunctionElement = null;
if (children != null && children.Any())
{
if (phrase.getFeatureAsBoolean(Feature.RAISE_SPECIFIER))
{
raiseSpecifier(children);
}
NLGElement child = phrase.LastCoordinate;
child.setFeature(Feature.POSSESSIVE, phrase.getFeature(Feature.POSSESSIVE));
child = children[0];
setChildFeatures(phrase, child);
coordinated.addCoordinate(parent.realise(child));
for (int index = 1; index < children.Count; index++)
{
child = children[index];
setChildFeatures(phrase, child);
if (phrase.getFeatureAsBoolean(Feature.AGGREGATE_AUXILIARY))
{
child.setFeature(InternalFeature.REALISE_AUXILIARY, false);
}
if (child.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.CLAUSE)))
{
child.setFeature(Feature.SUPRESSED_COMPLEMENTISER, phrase.getFeature(Feature.SUPRESSED_COMPLEMENTISER));
}
//skip conjunction if it's null or empty string
if (!ReferenceEquals(conjunction, null) && conjunction.Length > 0)
{
conjunctionElement = new InflectedWordElement(conjunction, new LexicalCategory(LexicalCategory.LexicalCategoryEnum.CONJUNCTION));
conjunctionElement.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.CONJUNCTION);
coordinated.addCoordinate(conjunctionElement);
}
coordinated.addCoordinate(parent.realise(child));
}
realisedElement.addComponent(coordinated);
}
PhraseHelper.realiseList(parent, realisedElement, phrase.PostModifiers, DiscourseFunction.POST_MODIFIER);
PhraseHelper.realiseList(parent, realisedElement, phrase.Complements, DiscourseFunction.COMPLEMENT);
}
return(realisedElement);
}
/**
* Checks the subjects of the phrase to determine if there is more than one
* subject. This ensures that the verb phrase is correctly set. Also set
* person correctly
*
* @param phrase
* the <code>PhraseElement</code> representing this clause.
* @param verbElement
* the <code>NLGElement</code> representing the verb phrase for
* this clause.
*/
private static void checkSubjectNumberPerson(PhraseElement phrase, NLGElement verbElement)
{
NLGElement currentElement = null;
IList <NLGElement> subjects = phrase.getFeatureAsElementList(InternalFeature.SUBJECTS);
bool pluralSubjects = false;
Person?person = null;
if (subjects != null)
{
switch (subjects.Count)
{
case 0:
break;
case 1:
currentElement = subjects[0];
// coordinated NP with "and" are plural (not coordinated NP with "or")
if (currentElement is CoordinatedPhraseElement && ((CoordinatedPhraseElement)currentElement).checkIfPlural())
{
pluralSubjects = true;
}
else if (((NumberAgreement?)currentElement.getFeature(Feature.NUMBER) == NumberAgreement.PLURAL) && !(currentElement is SPhraseSpec)) // ER mod-
{
// ER mod-clauses are singular as NPs, even if they are plural internally
pluralSubjects = true;
}
else if (currentElement.isA(new PhraseCategory(PhraseCategory.PhraseCategoryEnum.NOUN_PHRASE)))
{
NLGElement currentHead = currentElement.getFeatureAsElement(InternalFeature.HEAD);
person = (Person?)currentElement.getFeature(Feature.PERSON);
if (currentHead == null)
{
// subject is null and therefore is not gonna be plural
pluralSubjects = false;
}
else if ((NumberAgreement?)currentHead.getFeature(Feature.NUMBER) == NumberAgreement.PLURAL)
{
pluralSubjects = true;
}
else if (currentHead is ListElement)
{
pluralSubjects = true;
/*
* } else if (currentElement instanceof
* CoordinatedPhraseElement &&
* "and".equals(currentElement.getFeatureAsString(
* //$NON-NLS-1$ Feature.CONJUNCTION))) { pluralSubjects
* = true;
*/
}
}
break;
default:
pluralSubjects = true;
break;
}
}
if (verbElement != null)
{
verbElement.setFeature(Feature.NUMBER, pluralSubjects ? NumberAgreement.PLURAL : (NumberAgreement?)phrase.getFeature(Feature.NUMBER));
if (person != null)
{
verbElement.setFeature(Feature.PERSON, person);
}
}
}