CODEWITHSUNDEEP
groovycomparisonoperator-overloading
tsquared
tsquared

Reputation: 119

Problems overloading Groovy comparison operators

I am building an analytic application using Groovy and require very forgiving math operators regardless of data format. I achieve this through operator overloading, in many cases improving (in my case) on the default Groovy type flexibility. As an example, I need 123.45f + "05" to equal 128.45f. By default Groovy downgrades to String and I get 123.4505.

In most cases my overloading works very well, but not for comparison operators. I've followed a couple of discussions on this, but I'm not getting to an answer and I'm looking for ideas. I recognize that the goal is to overload compareTo() (vs. something like lessThan), but Groovy seems to ignore this and instead attempts its own smart comparison - e.g. DefaultTypeTransformation.compareTo(Object left, Object right), which fails on mixed types.

Unfortunately this is a must have for me, because improperly comparing two values compromises the whole solution and I don't have control over some of the data types being analyzed (e.g. vendor data structures).

For example, I need the following to work:

Float f = 123.45f;
String s = "0300";

Assert.assertTrue( f < s );

I have many permutations of these, but my attempt to overload includes (let's just assume my JavaTypeUtil does what I need if I can get Groovy to call it):

// overloads on startup, trying to catch all cases
Float.metaClass.compareTo = {
    Object o -> JavaTypeUtil.compareTo(delegate, o)  }

Float.metaClass.compareTo = {
    String s -> JavaTypeUtil.compareTo(delegate, s)  }

Object.metaClass.compareTo = {
    String s -> JavaTypeUtil.compareTo(delegate, s) }

Object.metaClass.compareTo = {
    Object o -> JavaTypeUtil.compareTo(delegate, o) }

When I try the above test, none of these are called and instead I get: 

    java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Float
at java.lang.Float.compareTo(Float.java:50)
at org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation.compareToWithEqualityCheck(DefaultTypeTransformation.java:585)
at org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation.compareTo(DefaultTypeTransformation.java:540)
at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.compareTo(ScriptBytecodeAdapter.java:690)
at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.compareLessThan(ScriptBytecodeAdapter.java:710)
at com.modelshop.datacore.generator.GroovyMathTests.testMath(GroovyMathTests.groovy:32)

Debugging through I see that the < operator goes right to ScriptBytecodeAdapter.compareLessThan(), and the implementation of that seems to ignore the overloaded compareTo() here:

In DefaultTypeTransformations.java:584 (2.4.3)

        if (!equalityCheckOnly || left.getClass().isAssignableFrom(right.getClass())
                || (right.getClass() != Object.class && right.getClass().isAssignableFrom(left.getClass())) //GROOVY-4046
                || (left instanceof GString && right instanceof String)) {
            Comparable comparable = (Comparable) left;
            return comparable.compareTo(right);          // <--- ***
        }

In a desperate attempt, I've also tried to overload compareLessThan, but I'm grasping now, I don't know that there's any way to jump in front of the < mapping in Groovy.

        Float.metaClass.compareLessThan << {
            Object right -> JavaTypeUtil.compareTo(delegate, right) < 0 }
        Float.metaClass.compareLessThan << {
            String right -> JavaTypeUtil.compareTo(delegate, right) < 0 }

Any thoughts on a work-around? Thanks!

Upvotes: 4

Views: 1289

Answers (2)

Keegan
Keegan

Reputation: 12207

Part of it is you need to include static, like this

Float.metaClass.static.compareTo = { String s -> 0 }

This makes f.compareTo(s) work, but the < operator still won't work. This is a known limitation. The only operators that can be overloaded are mentioned in the documentation. Possibly you could do a custom AST to change all those operators to a compareTo().

But this isn't the whole story. f <=> s also doesn't work, despite <=> delegating to compareTo(). I believe this is because Float doesn't implement Comparable<Object> or Comparable<String>, only Comparable<Float>. Although I'm not sure where exactly in the chain Groovy makes the decision not to use that method, you can see it's not limited to Groovy's math classes. This also doesn't work

Foo.metaClass.compareTo = { String s -> 99 }
new Foo() <=> ''

class Foo implements Comparable<Foo> {
    int compareTo(Foo o) {
        0
    }
}

I think Groovy is doing some pre-parsing validation that's preventing the metaclass stuff from working. Whatever validation it's doing definitely inspects the interfaces implemented, because this fails for a different reason

Foo.metaClass.compareTo = { String s -> 99 }
new Foo() <=> ''

class Foo {
    int compareTo(Foo o) {
        0
    }
}

In both of these examples, replacing <=> with compareTo() works.

This question has been asked a couple times before, but I haven't seen a good explanation for why. You might try asking on the user mailing list. I'm sure Jochen or Cedric would be able to explain why.

Upvotes: 3

BahmanM
BahmanM

Reputation: 1445

I guess the point is that your compareTo closure is expecting an Object; so when you invoke compareTo with a String, your closure doesn't get called at all.

I can only think of the following; being precise when specifying closure input parameter type:

Float.metaClass.compareTo = { Integer n -> aStaticHelperMethod(n) }
Float.metaClass.compareTo = { String s -> aStaticHelperMethod(s) }
Float.metaClass.compareTo = { SomeOtherType o -> aStaticHelperMethod(o) }

Upvotes: 0

Related Questions