//
// PRIVATE
//
private void assertLegalArguments(Connective connective, params Sentence[] sentences)
{
if (connective == null)
{
throw new ArgumentException("Connective must be specified.");
}
if (sentences == null)
{
throw new ArgumentException("> 0 simpler sentences must be specified.");
}
if (connective == Connective.NOT)
{
if (sentences.Length != 1)
{
throw new ArgumentException("A not (~) complex sentence only take 1 simpler sentence not " + sentences.Length);
}
}
else
{
if (sentences.Length != 2)
{
throw new ArgumentException("Connective is binary (" + connective + ") but only " + sentences.Length + " simpler sentences provided");
}
}
}
/**
* Constructor.
*
* @param connective
* the complex sentence's connective.
* @param sentences
* the simpler sentences making up the complex sentence.
*/
public ComplexSentence(Connective connective, params Sentence[] sentences)
{
// Assertion checks
assertLegalArguments(connective, sentences);
this.connective = connective;
simplerSentences = new Sentence[sentences.Length];
for (int i = 0; i < sentences.Length; i++)
{
simplerSentences[i] = sentences[i];
}
}
/**
* Utility routine that will create a string representation of a given
* Sentence and place it inside brackets if it is a complex sentence that
* has lower precedence than this complex sentence.<br>
* <br>
* Note: this is a form of pretty printing, whereby we only add brackets in
* the concrete syntax representation as needed to ensure it can be parsed
* back again into an equivalent abstract syntax representation used here.
*
* @param parentConnective
* the connective of the parent sentence.
* @param childSentence
* a simpler child sentence.
* @return a String representation of the Sentence, bracketed if the parent
* based on its connective has higher precedence.
*/
public String bracketSentenceIfNecessary(Connective parentConnective,
Sentence childSentence)
{
String result = null;
if (childSentence is ComplexSentence)
{
ComplexSentence cs = (ComplexSentence)childSentence;
if (cs.getConnective().getPrecedence() < parentConnective
.getPrecedence())
{
result = "(" + childSentence + ")";
}
}
if (result == null)
{
result = childSentence.ToString();
}
return(result);
}
/**
* Convenience constructor for binary sentences.
*
* @param sentenceL
* the left hand sentence.
* @param binaryConnective
* the binary connective.
* @param sentenceR
* the right hand sentence.
*/
public ComplexSentence(Sentence sentenceL, Connective binaryConnective, Sentence sentenceR) : this(binaryConnective, sentenceL, sentenceR)
{
}
// PROTECTED
protected bool hasConnective(Connective connective)
{
// Note: can use '==' as Connective is an enum.
return(getConnective() == connective);
}
