// Compara esta sentencia compuesta con otra y dice si son iguales
public bool Equals(ComplexSentence cs)
{
if (cs == null)
{
return(false);
}
if (this == cs)
{
return(true);
}
bool result = false;
if (cs.GetHashCode() == this.GetHashCode())
{
if (cs.GetConnective().Equals(this.GetConnective()) &&
cs.GetNumberSimplerSentences() == this.GetNumberSimplerSentences())
{
// Si la conectiva y el número de sentencias más simples coincide, asumir que hay coincidencia y pasar a comprobar CADA sentencia simple
result = true;
for (int i = 0; i < this.GetNumberSimplerSentences(); i++)
{
if (!cs.GetSimplerSentence(i).Equals(this.GetSimplerSentence(i)))
{
result = false;
break;
}
}
}
}
return(result);
}
/**
* Rutina de utilidad que creará una representación en forma de cadena de una sentencia dada y la colocará entre paréntesis si es una sentencia compleja de menor precedencia que esta sentencia compleja.
* Nota: Esta es una forma de imprimir más bonita, donde sólo añadimos paréntesis en la representación de la sintaxis concreta si se necesitan
* para asegurarnos que se puede parsear de vuelta en la representación de sintaxix abstracta equivalente que usamos aquí.
*
* @param parentConnective
* la conectiva de la sentencia padre.
* @param childSentence
* una sentencia hija más simple.
* @return una representación en forma de cadena de la sentencia, entre paréntesis si el padre tiene mayor precedencia basándonos en su conectiva.
*/
public string BracketSentenceIfNecessary(Connective parentConnective, Sentence childSentence)
{
string result = null;
if (childSentence is ComplexSentence)
{
ComplexSentence cs = (ComplexSentence)childSentence;
if (cs.GetConnective().Precedence < parentConnective.Precedence)
{
result = "(" + childSentence + ")";
}
}
if (result == null)
{
result = childSentence.ToString();
}
return(result);
}
