Method: toString()

1: package pruefskript.parser.nodes;
2:
3: import basic.PruefskriptConstants;
4: import pruefskript.CommunicationManager;
5: import pruefskript.parser.exceptions.CheckScriptException;
6: import pruefskript.parser.exceptions.WrongNodeException;
7: import pruefskript.parser.values.AbstractReturnValue;
8: import pruefskript.parser.values.BooleanValue;
9:
10: /**
11: * EqualNode.
12: *
13: * @author Phil
14: *
15: */
16: public class EqualNode extends AbstractBinaryOperationNode {
17:
18:         /**
19:          * EqualNode.
20:          *
21:          * @param operand1
22:          * AbstractNode
23:          * @param operand2
24:          * AbstractNode
25:          */
26:         public EqualNode(final AbstractNode operand1, final AbstractNode operand2) {
27:                 super(operand1, operand2);
28:         }
29:
30:         @Override
31:         public String toString() {
32:                 return PruefskriptConstants.EQUALNODETITLE + PruefskriptConstants.BRACKET_OPEN
33:                                 + super.toString() + PruefskriptConstants.BRACKET_CLOSE;
34:         }
35:
36:         @Override
37:         public boolean equals(final Object obj) {
38:                 return super.equals(obj) && obj instanceof EqualNode;
39:
40:         }
41:
42:         @Override
43:         public int hashCode() {
44:                 return super.hashCode() + PruefskriptConstants.EQUALNODE_HASHCODE;
45:         }
46:
47:         /**
48:          * Wertet die beiden Operanten separat aus. Prueft, ob die Typen der Operanten erlaubt sind und
49:          * gibt als Ergebnis zurueck, ob die Operanten die Gleichen sind. Ansonsten wird eine Exception
50:          * geworfen.
51:          */
52:         @Override
53:         public BooleanValue interpret(final CommunicationManager mgr) throws CheckScriptException {
54:                 final AbstractReturnValue op1 = this.getOperand1().interpret(mgr);
55:                 final AbstractReturnValue op2 = this.getOperand2().interpret(mgr);
56:                 final BooleanValue resultBool;
57:                 if (checkOpsAllowed(op1, op2)) {
58:                         resultBool = new BooleanValue(
59:                                         op1.getStringRepresentation().equals(op2.getStringRepresentation()));
60:                 } else {
61:                         throw new WrongNodeException(PruefskriptConstants.UNEXPECTED_BOOL_OPERATION);
62:                 }
63:                 return resultBool;
64:         }
65:
66:         /**
67:          * Ueberprueft ob die Operanten erlaubte Typen besitzen.
68:          *
69:          * @param op1
70:          * Der erste Operant.
71:          * @param op2
72:          * Der zweite Operant.
73:          * @return bool, ob die Operaten zusammenpassen.
74:          */
75:         private boolean checkOpsAllowed(final AbstractReturnValue op1,
76:                         final AbstractReturnValue op2) {
77:                 final boolean versions = op1.isVersionValue() && op2.isVersionValue();
78:                 final boolean numerics = op1.isNumericValue() && op2.isNumericValue();
79:                 final boolean strings = op1.isStringValue() && op2.isStringValue();
80:                 final boolean booleans = op1.isBooleanValue() && op2.isBooleanValue();
81:                 final boolean stringnumvalue = op1.isStringValue() && op2.isNumericValue();
82:                 return versions || numerics || strings || booleans || stringnumvalue;
83:         }
84: }