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) <= 0);
}
catch (ArgumentException ae)
{
runtimeServices.Error(ae.Message);
return(false);
}
}
public override bool Evaluate(IInternalContextAdapter context)
{
Object left = GetChild(0).Value(context);
Object right = GetChild(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);
}
/// <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(IInternalContextAdapter context)
{
Object left = GetChild(0).Value(context);
Object right = GetChild(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);
}