/// <summary> Calculates the value of the logical expression /// * /// arg1 == arg2 /// * /// All class types are supported. Uses equals() to /// determine equivalence. This should work as we represent /// with the types we already support, and anything else that /// implements equals() to mean more than identical references. /// * /// * /// </summary> /// <param name="context"> internal context used to evaluate the LHS and RHS /// </param> /// <returns>true if equivalent, false if not equivalent, /// false if not compatible arguments, or false /// if either LHS or RHS is null /// /// </returns> public override bool evaluate(InternalContextAdapter context) { Object left = jjtGetChild(0).Value(context); Object right = jjtGetChild(1).Value(context); /* * for equality, they are allowed to be null references */ try { if (ObjectComparer.CompareObjects(left, right) == 0) { return(true); } } catch { // Ignore, we can't compare decently by value, but we honestly don't give a sh*t } // They are not equal by value, try a reference comparison // reference equal => definitely equal objects ;) // For operator overloaded types, this will not really be a reference comp, but that's ok. return(left == right); }
public override bool Evaluate(IInternalContextAdapter context) { // get the two args Object left = GetChild(0).Value(context); Object right = GetChild(1).Value(context); // if either is null, lets log and bail if (left == null || right == null) { runtimeServices.Error( string.Format( "{0} side ({1}) of '<' operation has null value. Operation not possible. {2} [line {3}, column {4}]", (left == null ? "Left" : "Right"), GetChild((left == null ? 0 : 1)).Literal, context.CurrentTemplateName, Line, Column)); return(false); } try { return(ObjectComparer.CompareObjects(left, right) == ObjectComparer.Smaller); } catch (ArgumentException argumentException) { runtimeServices.Error(argumentException.Message); return(false); } }
static ObjectComparer() { ObjectComparer.comparers = new Hashtable(); ObjectComparer.instance = new ObjectComparer(); new ObjectComparer.DoubleComparer().Register(ObjectComparer.comparers); new ObjectComparer.FloatComparer().Register(ObjectComparer.comparers); new ObjectComparer.ULongComparer().Register(ObjectComparer.comparers); }
public override bool Evaluate(IInternalContextAdapter context) { object obj = base.GetChild(0).Value(context); object obj2 = base.GetChild(1).Value(context); bool result; try { result = (ObjectComparer.CompareObjects(obj, obj2) != 0); return(result); } catch { } result = (obj != obj2); return(result); }
public override bool evaluate(InternalContextAdapter context) { Object left = jjtGetChild(0).Value(context); Object right = jjtGetChild(1).Value(context); try { return(ObjectComparer.CompareObjects(left, right) != 0); } catch { // Ignore, we can't compare decently by value, but we honestly don't give a sh*t } // If we can't actually compare the objects, try the operator as fallback // For operator overloaded types, this will not really be a reference comp, but that's ok. return(left != right); }
/// <seealso cref="org.apache.velocity.runtime.parser.node.SimpleNode.evaluate(org.apache.velocity.context.InternalContextAdapter)"> /// </seealso> public override bool Evaluate(IInternalContextAdapter context) { /* * get the two args */ object left = GetChild(0).Value(context); object right = GetChild(1).Value(context); /* * if either is null, lets log and bail */ if (left == null || right == null) { System.String msg = (left == null ? "Left" : "Right") + " side (" + GetChild((left == null ? 0 : 1)).Literal + ") of '>=' operation has null value at " + Log.FormatFileString(this); if (rsvc.GetBoolean(RuntimeConstants.RUNTIME_REFERENCES_STRICT, false)) { throw new VelocityException(msg); } log.Error(msg); return(false); } try { return(ObjectComparer.CompareObjects(left, right) >= 0); } catch (ArgumentException ae) { log.Error(ae.Message); return(false); } }
public override bool Evaluate(IInternalContextAdapter context) { object obj = base.GetChild(0).Value(context); object obj2 = base.GetChild(1).Value(context); bool result; if (obj == null || obj2 == null) { this.rsvc.Error(string.Concat(new object[] { (obj == null) ? "Left" : "Right", " side (", base.GetChild((obj == null) ? 0 : 1).Literal, ") of '>=' operation has null value. Operation not possible. ", context.CurrentTemplateName, " [line ", base.Line, ", column ", base.Column, "]" })); result = false; } else { try { result = (ObjectComparer.CompareObjects(obj, obj2) >= 0); } catch (ArgumentException ex) { this.rsvc.Error(ex.Message); result = false; } } return(result); }