/**
* ~Set the features for a sentence. This method also checks whether any
* features have been set on the VP, in which case, they are set if they
* haven't been set on the S
*
* @param wp
* the xml SPhraseSpec object
* @param sp
* the sentence.
* @param vp
* the verb phrase.
*/
private void setSFeatures(wrapper.XmlSPhraseSpec wp, SPhraseSpec sp, NLGElement vp)
{
if (wp.CLAUSESTATUS != null)
{
Enum.TryParse(wp.CLAUSESTATUS.ToString(), out ClauseStatus clauseStatus);
sp.setFeature(InternalFeature.CLAUSE_STATUS, clauseStatus);
}
if (wp.PERSON != null)
{
Enum.TryParse(wp.PERSON.ToString(), out Person person);
sp.setFeature(Feature.PERSON, person);
}
if (wp.FORM != null)
{
Enum.TryParse(wp.FORM.ToString(), out Form form);
sp.setFeature(Feature.FORM, form);
}
if (wp.TENSE != null)
{
Enum.TryParse(wp.TENSE.ToString(), out Form tense);
sp.setFeature(Feature.TENSE, tense);
}
else if (vp != null && vp.hasFeature(Feature.TENSE))
{
sp.setFeature(Feature.TENSE, vp.getFeature(Feature.TENSE));
}
// modal -- set on S or inherited from VP
if (wp.MODAL != null)
{
sp.setFeature(Feature.MODAL, wp.MODAL);
}
else if (vp != null && vp.hasFeature(Feature.MODAL))
{
sp.setFeature(Feature.MODAL, vp.getFeature(Feature.MODAL));
}
// interrogative
if (wp.INTERROGATIVETYPE != null)
{
Enum.TryParse(wp.INTERROGATIVETYPE.ToString(), out InterrogativeType interrogativeType);
sp.setFeature(Feature.INTERROGATIVE_TYPE, interrogativeType);
}
else if (vp != null && vp.hasFeature(Feature.INTERROGATIVE_TYPE))
{
sp.setFeature(Feature.INTERROGATIVE_TYPE, vp.getFeature(Feature.INTERROGATIVE_TYPE));
}
// set on clauses.
bool sAggregateAuxiliary = wp.AGGREGATEAUXILIARY ?? false;
bool vAggregateAuxiliary = vp?.getFeatureAsBoolean(Feature.AGGREGATE_AUXILIARY) ?? false;
sp.setFeature(Feature.AGGREGATE_AUXILIARY, sAggregateAuxiliary || vAggregateAuxiliary);
// passive: can be set on S or VP
bool sPass = wp.PASSIVE ?? false;
bool vPass = vp?.getFeatureAsBoolean(Feature.PASSIVE) ?? false;
sp.setFeature(Feature.PASSIVE, sPass || vPass);
// progressive: can be set on S or VP
bool sProg = wp.PROGRESSIVE ?? false;
bool vProg = vp?.getFeatureAsBoolean(Feature.PROGRESSIVE) ?? false;
sp.setFeature(Feature.PROGRESSIVE, sProg || vProg);
// perfect: can be set on S or VP
bool sPerf = wp.PERFECT ?? false;
bool vPerf = vp?.getFeatureAsBoolean(Feature.PERFECT) ?? false;
sp.setFeature(Feature.PERFECT, sPerf || vPerf);
// negation: can be set on S or VP
bool sNeg = wp.NEGATED ?? false;
bool vNeg = vp?.getFeatureAsBoolean(Feature.NEGATED) ?? false;
sp.setFeature(Feature.NEGATED, sNeg || vNeg);
// set on clauses.
bool ssgg = wp.SUPPRESSGENITIVEINGERUND ?? false;
bool vsgg = vp?.getFeatureAsBoolean(Feature.SUPPRESS_GENITIVE_IN_GERUND) ?? false;
sp.setFeature(Feature.SUPPRESS_GENITIVE_IN_GERUND, ssgg || vsgg);
// set on clauses.
bool ssc = wp.SUPRESSEDCOMPLEMENTISER ?? false;
bool vsc = vp?.getFeatureAsBoolean(Feature.SUPRESSED_COMPLEMENTISER) ?? false;
sp.setFeature(Feature.SUPRESSED_COMPLEMENTISER, ssc || vsc);
}
/**
* Unwrap a <code>simplenlg.xmlrealiser.wrapper.NLGElement</code> and map it
* to a <code>simplenlg.framework.NLGElement</code>
*
* @param wps
* The wrapper object
* @return the NLGElement
*/
public virtual NLGElement UnwrapNLGElement(wrapper.XmlNLGElement wps)
{
if (wps == null)
{
return(null);
}
if (wps is wrapper.XmlDocumentElement)
{
return((NLGElement)UnwrapDocumentElement((wrapper.XmlDocumentElement)wps));
}
// Handle coordinate phrase specs first, which will cause recursion.
NLGElement cp = UnwrapCoordinatePhraseSpec(wps);
if (cp != null)
{
return(cp);
}
// Literal text.
if (wps is wrapper.XmlStringElement)
{
wrapper.XmlStringElement wp = (wrapper.XmlStringElement)wps;
NLGElement p = factory.createStringElement(wp.Val);
return(p);
}
// WordElements (delegate to UnwrapWordElement) -- useful to have
// because it is called by unWrapPhraseComponents, and pre/post mods
// might be WordElements
if (wps is XmlWordElement)
{
return(UnwrapWordElement((XmlWordElement)wps));
}
// Sentence
else if (wps is wrapper.XmlSPhraseSpec)
{
wrapper.XmlSPhraseSpec wp = (wrapper.XmlSPhraseSpec)wps;
SPhraseSpec sp = factory.createClause();
NLGElement vp = null;
List <NLGElement> subjects = new List <NLGElement>();
foreach (wrapper.XmlNLGElement p in wp.Subj)
{
NLGElement p1 = UnwrapNLGElement(p);
checkFunction(DiscourseFunction.SUBJECT, p1);
subjects.Add(p1);
}
if (subjects.Any())
{
sp.setFeature(InternalFeature.SUBJECTS, subjects);
}
if (wp.Vp != null)
{
vp = UnwrapNLGElement(wp.Vp);
sp.VerbPhrase = vp;
}
if (wp.CuePhrase != null)
{
NLGElement cue = UnwrapNLGElement(wp.CuePhrase);
cue.setFeature(InternalFeature.DISCOURSE_FUNCTION, DiscourseFunction.CUE_PHRASE);
sp.setFeature(Feature.CUE_PHRASE, cue);
}
if (wp.COMPLEMENTISER != null)
{
sp.setFeature(Feature.COMPLEMENTISER, wp.COMPLEMENTISER);
}
setSFeatures(wp, sp, vp);
// Common phrase components.
UnwrapPhraseComponents(sp, wps);
return(sp);
}
// Phrases
else if (wps is wrapper.XmlPhraseElement)
{
wrapper.XmlPhraseElement we = (wrapper.XmlPhraseElement)wps;
PhraseElement hp = null;
XmlWordElement w = we.Head;
NLGElement head = UnwrapWordElement(w);
// NLGElement head;
// simplenlg.xmlrealiser.wrapper.XmlNLGElement w =
// we.getHeadstring();
// check whether we have a stringelement or wordelement as head
// if(w == null) {
// w = we.getHeadword();
// head = UnwrapWordElement((XmlWordElement) w);
//
// } else {
// head = factory.createStringElement(((XmlStringElement)
// w).getVal());
// }
// Noun Phrase
if (wps is wrapper.XmlNPPhraseSpec)
{
wrapper.XmlNPPhraseSpec wp = (wrapper.XmlNPPhraseSpec)wps;
NPPhraseSpec p = factory.createNounPhrase(head);
hp = p;
if (wp.Spec != null)
{
// p.setSpecifier(UnwrapWordElement(wp.getSpec()));
wrapper.XmlNLGElement spec = wp.Spec;
if (spec is XmlWordElement)
{
WordElement specifier = (WordElement)UnwrapWordElement((XmlWordElement)spec);
if (specifier != null)
{
p.setSpecifier(specifier);
}
}
else
{
p.setSpecifier(UnwrapNLGElement(spec));
}
}
setNPFeatures(wp, p);
}
// Adjective Phrase
else if (wps is wrapper.XmlAdjPhraseSpec)
{
wrapper.XmlAdjPhraseSpec wp = (wrapper.XmlAdjPhraseSpec)wps;
AdjPhraseSpec p = factory.createAdjectivePhrase(head);
hp = p;
p.setFeature(Feature.IS_COMPARATIVE, wp.ISCOMPARATIVE);
p.setFeature(Feature.IS_SUPERLATIVE, wp.ISSUPERLATIVE);
}
// Prepositional Phrase
else if (wps is wrapper.XmlPPPhraseSpec)
{
PPPhraseSpec p = factory.createPrepositionPhrase(head);
hp = p;
}
// Adverb Phrase
else if (wps is wrapper.XmlAdvPhraseSpec)
{
wrapper.XmlAdvPhraseSpec wp = (wrapper.XmlAdvPhraseSpec)wps;
AdvPhraseSpec p = factory.createAdverbPhrase();
p.setHead(head);
hp = p;
p.setFeature(Feature.IS_COMPARATIVE, wp.ISCOMPARATIVE);
p.setFeature(Feature.IS_SUPERLATIVE, wp.ISSUPERLATIVE);
}
// Verb Phrase
else if (wps is wrapper.XmlVPPhraseSpec)
{
wrapper.XmlVPPhraseSpec wp = (wrapper.XmlVPPhraseSpec)wps;
VPPhraseSpec p = factory.createVerbPhrase(head);
hp = p;
setVPFeatures(wp, p);
}
// Common phrase components.
UnwrapPhraseComponents(hp, wps);
// set the discourse function, if defined
if (we.DiscourseFunction != null)
{
DiscourseFunction func;
Enum.TryParse(we.DiscourseFunction.ToString(), out func);
hp.setFeature(InternalFeature.DISCOURSE_FUNCTION, func);
}
// check the appositive feature
bool?appositive = we.Appositive;
if (appositive != null)
{
hp.setFeature(Feature.APPOSITIVE, appositive);
}
return(hp);
}
return(null);
}
