GDK Overview & Object Methods

// String.center() does not exist in the JDK: it is a GDK extension method
println String.declaredMethods.any { it.name == 'center' }
println 'ok'.center(8, '*')

def m = String.metaClass.getMetaMethods().find { it.name == 'center' && it.parameterTypes.size() == 2 }
println m.declaringClass.name                    // the receiver type that the method extends
println 'ok'.metaClass.respondsTo('ok', 'center').size() > 0

// the Object methods covered below, as the metaclass sees them
println(Object.metaClass.getMetaMethods()*.name.findAll { it in ['with', 'tap', 'inspect', 'dump', 'identity', 'is', 'sleep'] }.unique().sort())
println !5.respondsTo('times').isEmpty()

false
***ok***
java.lang.CharSequence
true
[dump, identity, inspect, is, sleep, tap, with]
true

class Sensor { String id; String zone; double reading }

def s = new Sensor()
def r = s.with {                 // with: delegate is the receiver, result is the closure result
    id = 'T-01'
    zone = 'north'
    reading = 21.5
    "configured $id"
}
println r

def t = s.tap { reading += 1 }   // tap: result is the receiver itself
println t.is(s)
println s.reading

def sb = new StringBuilder().tap { append('a'); append('b') }
println sb

println s.with { it.zone.toUpperCase() }   // the receiver is also passed as it

Sensor maybe = null
println maybe?.with { id }                 // safe navigation skips the closure
println 5.identity { it + 1 }              // identity is an alias of with

5.each { println "each on a single object: $it" }    // Object.each treats a non-collection as one element

configured T-01
true
22.5
ab
NORTH
null
6
each on a single object: 5

class Sensor { String id; String zone; double reading }
def s = new Sensor(id: 'T-01', zone: 'north', reading: 21.5)

println s.dump().replaceAll(/@[0-9a-f]+/, '@hash')   // dump lists every field with its value
println 'a\tb'.inspect()                              // inspect gives source-like text
println 'a\tb'
println([1, 'two', 3.0, null, [k: 'v']].inspect())
println([1, 'two', 3.0, null, [k: 'v']].toString())

def text = [1, 'two', 3.0, null, [k: 'v']].inspect()
assert Eval.me(text) == [1, 'two', 3.0, null, [k: 'v']]    // inspect output can be evaluated back
println 'round trip ok'

println s.properties.keySet().sort()                  // getProperties(): a Map of the bean properties
println s.properties.subMap(['id', 'zone'])

def twin = new Sensor(id: 'T-01', zone: 'north', reading: 21.5)
println s == twin               // == calls equals(), which Sensor does not override
println s.is(s)
println s.is(twin)              // is(): identity, never overridable

<Sensor@hash id=T-01 zone=north reading=21.5>
'a\tb'
a	b
[1, 'two', 3.0, null, ['k':'v']]
[1, two, 3.0, null, [k:v]]
round trip ok
[class, id, reading, zone]
[id:T-01, zone:north]
false
true
false

def started = System.nanoTime()
sleep(200)
def ms = (System.nanoTime() - started).intdiv(1_000_000)
println ms >= 200

def t = Thread.start {
    sleep(60_000) { e -> println "interrupted: ${e.class.simpleName}"; true }   // true: stop sleeping
}
sleep(100)
t.interrupt()
t.join()
println 'done'

true
interrupted: InterruptedException
done

def config = new ConfigSlurper('production').parse('''
greenhouse {
    name = 'North Hall'
    sampleSeconds = 30
    limits {
        minTemp = 12.0
        maxTemp = 30.0
    }
}
environments {
    development { greenhouse.sampleSeconds = 5 }
    production  { greenhouse.sampleSeconds = 60 }
}
''')
println config.greenhouse.name
println config.greenhouse.sampleSeconds
println config.greenhouse.limits.maxTemp
println config.flatten()['greenhouse.limits.minTemp']
println config.greenhouse.limits.containsKey('minTemp')
println config.greenhouse.missing instanceof ConfigObject
println config.isSet('nothing')
println config.greenhouse.limits.keySet().toList()
println config.toProperties().getProperty('greenhouse.name')
def dev = new ConfigSlurper('development').parse("""
greenhouse { sampleSeconds = 30 }
environments { development { greenhouse.sampleSeconds = 5 } }
""")
println dev.greenhouse.sampleSeconds

North Hall
60
30.0
12.0
true
true
false
[minTemp, maxTemp]
North Hall
5

def zone = new Expando(id: 'north', targetTemp: 21.0)
zone.describe = { -> "zone ${delegate.id} target ${delegate.targetTemp}" }
zone.raise = { double d -> delegate.targetTemp += d; delegate }
println zone.describe()
zone.raise(1.5).raise(0.5)         // raise returns the Expando, so calls chain
println zone.targetTemp
println zone.nothing               // unknown names read as null, never an exception
println zone.properties.keySet().sort()
zone.toString = { -> "Zone(${delegate.id})" }
println zone
println "$zone"
println zone == new Expando(id: 'north')

zone north target 21.0
23.0
null
[describe, id, raise, targetTemp]
Zone(north)
Zone(north)
false

def log = []
def alarms = new ObservableList()
alarms.addPropertyChangeListener { e ->
    if (e.propertyName == 'size') return          // ignore the companion size event
    switch (e) {
        case ObservableList.ElementAddedEvent:   log << "added ${e.newValue} at ${e.index}"; break
        case ObservableList.ElementUpdatedEvent: log << "updated ${e.oldValue} -> ${e.newValue}"; break
        case ObservableList.ElementRemovedEvent: log << "removed ${e.oldValue}"; break
    }
}
alarms << 'frost'
alarms << 'wind'
alarms[0] = 'hard frost'
alarms.remove('wind')
println log
println alarms

def readings = new ObservableMap()
readings.addPropertyChangeListener { e ->
    if (e.propertyName != 'size') println "${e.class.simpleName}: ${e.propertyName} ${e.oldValue} -> ${e.newValue}"
}
readings.t1 = 20.5
readings.t1 = 21.0
readings.remove('t1')

def tags = new ObservableSet(['a'] as Set)
tags.addPropertyChangeListener { e ->
    if (e.propertyName != 'size') println "${e.class.simpleName}: ${e.newValue ?: e.oldValue}"
}
tags << 'b'
tags << 'b'                                        // already present: no event
tags.remove('a')

[added frost at 0, added wind at 1, updated frost -> hard frost, removed wind]
[hard frost]
PropertyAddedEvent: t1 null -> 20.5
PropertyUpdatedEvent: t1 20.5 -> 21.0
PropertyRemovedEvent: t1 21.0 -> null
ElementAddedEvent: b
ElementRemovedEvent: a

class Reading {
    String zone
    double celsius
    String toString() { "Reading[zone=$zone, celsius=$celsius]" }
    String groovyToString() { "$zone: $celsius C" }
}
def r = new Reading(zone: 'north', celsius: 21.5)
println r                          // println uses groovyToString
println "$r"
println([north: r])
println r.toString()               // the real toString() is untouched
println r.inspect()
println([1, 2, 3] as int[])        // Java would print [I@hash
println(1..4)

north: 21.5 C
north: 21.5 C
[north:north: 21.5 C]
Reading[zone=north, celsius=21.5]
north: 21.5 C
[1, 2, 3]
1..4

def attempt = { String label, Closure c ->
    try { println "$label: ${c()}" } catch (MissingMethodException e) { println "$label: MissingMethodException" }
}
attempt('list groupBy') { [1, 2, 3, 4].groupBy { it % 2 } }
attempt('set groupBy')  { ([1, 2, 3, 4] as Set).groupBy { it % 2 } }
attempt('map groupBy')  { [a: 1, b: 2, c: 3].groupBy { it.value % 2 } }
attempt('center')       { 'abc'.center(7, '*') }

$ groovy extensions.groovy
list groupBy: [1:[1, 3], 0:[2, 4]]
set groupBy: [1:[1, 3], 0:[2, 4]]
map groupBy: [1:[a:1, c:3], 0:[b:2]]
center: **abc**

$ JAVA_OPTS="-Dgroovy.extension.disable=groupBy" groovy extensions.groovy
list groupBy: MissingMethodException
set groupBy: MissingMethodException
map groupBy: MissingMethodException
center: **abc**

$ JAVA_OPTS="-Dgroovy.extension.disable=groupBy,center" groovy extensions.groovy
list groupBy: MissingMethodException
set groupBy: MissingMethodException
map groupBy: MissingMethodException
center: MissingMethodException