Question

I wanted to implement a default sort order in my domain class and immediately found it didn’t work with the getAll method. No biggie, I just used list instead. The thing is that the default sort order in a domain class does not allow you specify multiple sort fields (as seen here).

My goal is to sort all Foo objects first by the name of their Bar object, then by their own name.

class Foo {
    String name
    String Bar
}

class Bar {
    String name
}

How can I implement this in the domain class so I don’t have to specify a long/nasty comparator every time I call .list()?

One of my attempts:

static Comparator getComparator() { 
    def c = { a, b -> 
    def result = a.bar.name.compareTo( b.bar.name ); 
        if ( result == 0 ) {
            result = a.name.compareTo( b.name );
        }
    }
    return c as Comparator
}

Then I could just call Foo.list(Foo.getComparator())… if I could get it to work.

Update:

I think I am really close here, just having trouble with implementing two comparisons in the same sort closure.

Foo.list().sort{ a, b ->
    def result = a.bar.name <=> b.bar.name;
    // Things mess up when I put this if statement in.
    if( result == 0 ) {
        a.name <=> b.name
    }
}

Disco!

class Foo { // My domain class
    // ...

    static Comparator getComparator() {
        def c =[
            compare: { a, b ->
                def result = a.bar.name <=> b.bar.name;
                if( result == 0 ) {
                    result = a.name <=> b.name
                }
                return result
            }
        ] as Comparator
    }

    // ...
}

And implemented like this in my controller:

Foo.list().sort( Foo.getComparator() )

PS:

The above works, but Jeff Storey posted some code in his answer after I discoed, and his code works and is much nicer than mine so use it 🙂

Answer 1

In your case, would it make sense to have Foo implement Comparable and the implementation could do the comparison as you described? Then when you sort the objects in a list, because they are Comparable, they will sort properly.

If it does not make sense for you to implement Comparable though, you will need to specify a comparator to sort by.

Here’s some sample code based on your comments:

edit:

class Person implements Comparable<Person> {

   String firstName
   String lastName

   int compareTo(Person other) {
       int lastNameCompare = lastName <=> other.lastName
       return lastNameCompare != 0 ? lastNameCompare : firstName <=> other.firstName
   }

   String toString() {
     "${lastName},${firstName}"
   }
}

def people = [new Person(firstName:"John",lastName:"Smith"), new Person(firstName:"Bill",lastName:"Jones"), new Person(firstName:"Adam",lastName:"Smith")]
println "unsorted = ${people}"
println "sorted = ${people.sort()}" 

This prints:

unsorted = [Smith,John, Jones,Bill, Smith,Adam]
sorted = [Jones,Bill, Smith,Adam, Smith,John]