groovy 3 and the new groovy meta object protocol in examples

Unless otherwise indicated, these slides are © 2013-2014 Pivotal Software, Inc. and licensed under aCreative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/1

Groovy 3 the new Meta Object Protocol

in examples

Unless otherwise indicated, these slides are © 2013-2014 Pivotal Software, Inc. and licensed under aCreative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/

Jochen Theodorou, GoPivtoal Germany GmbH@JochenTheodorou


… in certainly not enough examples

Unless otherwise indicated, these slides are © 2013-2014 Pivotal Software, Inc. and licensed under aCreative Commons Attribution-NonCommercial license: http://creativecommons.org/licenses/by-nc/3.0/

Jochen Theodorou, GoPivtoal Germany GmbH@JochenTheodorou


What cannot go forwardgoes backwards.

Johann Wolfgang von Goethe (1749-1832), German PoetTranslation by Jochen Theodorou

“


Goals:

■ Metaclass as Persistent Collection and Realms

● Better multi threading performance

● Allowing different versions of metaclasses for same class

■ Only internal metaclasses

● no „extends MetaClassImpl“ any more, instead like ExpandoMetaClass for everything

● Delegation instead of Inheritance

■ MOP Methods

● Names and Signatures change to avoid conflicts with normal methods

● GroovyObject becomes a marker interface or is removed

● All methods then optional and in different variants

● No exception controlled MOP any more

■ Others

● All operators available for meta programmings

● Based on invokedynamic and ClassValue (Java 7 becomes minimum)


MOP Methods= in class defined methods to control MOP


Overview:

■ Uncached:

● Difficulty: I did hear of Groovy

● methodMissing, methodIntercept, propertyMissing, propertyIntercept

■ Cached 1:

● Difficulty: Me, want more. Now!

● cacheMethodMissing, cacheMethodIntercept, cachePropertyMissing,

cachePropertyIntercept

■ Cached 2:

● Difficulty: I know what I do! Give me the full program!

● cacheMethodTarget, cachePropertyTarget


MOP Methods – A Groovy BuilderGroovy 1 and Groovy 2

Groovy Builder in Groovy 1/2

class XmlBuilder { def out

def methodMissing(String name, args) { out << "<$name>" if(args[0] instanceof Closure) {

args[0].delegate = this args[0].call() } else {

out << args[0].toString() } out << "</$name>"

}}

def xml = new XmlBuilder(out:System.out) xml.html {

head { title "Hello World" }

body { p "Welcome!" }

}

console output:

<html><head><title>Hello World</title></head><body>Welcome!

</body></html>

}}




}

console output:


</body></html>

called if no method can be found for call

}}




}

console output:


</body></html>

name = name of callargs = arguments of call

} //implcit return !//implcit return !}




}

console output:


</body></html>The result of the call is theresult of methodMissing


MOP Methods – A Groovy BuilderGroovy 3 Uncached

Groovy Builder in Groovy 3 - Uncachedclass XmlBuilder {

def out MopResult methodMissing(String name, args) { out << "<$name>" If (args[0] instanceof Closure) {



return MopResult.VOID } }

def xml = new XmlBuilder(out:System.out) xml.html { head {

title "Hello World" } body {

p "Welcome!" } }

Groovy Builder uncached - before and after


def methodMissing (String name, args) { out << "<$name>"

if(args[0] instanceof Closure) { args[0].delegate = this args[0].call()

} else { out << args[0].toString() }

out << "</$name>" }}

class XmlBuilder {

def out MopResult methodMissing (String name, args) {

out << "<$name>" If (args[0] instanceof Closure) { args[0].delegate = this

args[0].call() } else { out << args[0].toString() }

out << "</$name>" return MopResult.VOID }

}

out << "</$name>" }}

class XmlBuilder {





}

MopResult contains theresult of the call

out << "</$name>" }}

class XmlBuilder {





}

it can also transport errorsor that there is no result (VOID)


MOP Methods – A Groovy BuilderGroovy 3 Cached

return how to get a result, instead of the result itself

Ein Groovy Builder in Groovy 3 - Cached

class XmlBuilder {

def out def methodMissing

(String name, args) {

out << "<$name>"

if(args[0] instanceof Closure) {

args[0].delegate = this

args[0].call()

} else { out << args[0].toString()

} out << "</$name>"

}

}

class XmlBuilder {

def out

void cacheMethodMissing (GroovyCall call, String name)

{ call.chain {out << "<${name}>"}

if(call[0].isAssignableTo(Closure))

{ call[0].chain

{it.delegate = this} call[0].execute()

} else {

call[0].execute "toString" }

call.chain {out << "</${name}>"} }

}

class XmlBuilder {



out << "<$name>"



args[0].call()


} out << "</$name>"

}

}

class XmlBuilder {

def out




{ call[0].chain


} else {



}

since there is no resultwe return void

class XmlBuilder {



out << "<$name>"



args[0].call()


} out << "</$name>"

}

}

class XmlBuilder {

def out




{ call[0].chain


} else {



}

GroovyCall is created foreach uncached call

class XmlBuilder {



out << "<$name>"



args[0].call()


} out << "</$name>"

}

}

class XmlBuilder {

def out




{ call[0].chain


} else {



}

No argument objects here,only their rutime classes


Some more details:

■ We provide a high-level API to let you express how to get to a result, not what the

result is – This allows caching in the first place

■ The to be cached method called can go through cacheMethodMissing more than

once. Reasons for that can be type changes for the arguments or the receiver

■ If you want to react different to different values of the same type, caching might be

not for you. (example: provide the method to be called as additional argument

instead)


MOP Methods – A Groovy BuilderGroovy 3 MethodHandles

Ein Groovy Builder in Groovy 3 – MethodHandles class XmlBuilder {

def out

private final MethodHandle outField = LOOKUP.findGetter....

void cacheMethodTarget

(GroovyCall call, String name)

{

call.chain(

GroovyInvoker.bind(outField,"leftShift","<${name}>"))

if (call.arg(0).isAsignableTo(Closure)) {

call.arg(0).chain(

GroovyInvoker.setProperty("delegate",this))

call.arg(0).execute()

} else {

call.arg(0).execute "toString"

}

call.chain(

GroovyInvoker.bind(outField,"leftShift","</${name}>"))

}

}


Some Explanations:

■ Target is to produce a MethodHandle

■ GroovyCall high-level API is helping you here and can be mixed with MethodHandles

■ Of course the MethodHandles-API from Java7 is efficient and powerful, but also

difficult to understand and handle – for example because types have to match

exactly

■ Ultimately (and only for the most crazy people) we want to provide a way to give

your own bootstrap method and then design yourself what you do with the call. This

way you could for example completely emulate Javalogik and also speed (of course

there is still an overhead through invokedynamic)


MOP Methods – Dynamic FinderGroovy 1 und Groovy 2


Dynamic Finder in Groovy 1/2

class GORM {

// an array of dynamic methods that use regex

def dynamicMethods = [...]

def methodMissing (String name, args) {

def method = dynamicMethods.find { it.match(name) }

if (method) {

GORM.metaClass."$name" = { Object[] varArgs ->

method.invoke(delegate, name, varArgs)

}

return method.invoke(delegate, name, args)

}

else throw new

MissingMethodException(name, delegate, args)

}

}



class GORM {





if (method) {



}


}

else throw new


}

}

adds a meta method to metaClassfor each missing method



class GORM {





if (method) {



}


}

else throw new


}

}

makes the metaClassstay in memory


The metaclass is in Groovy 1 and 2 actually linked to an instance, but has to be

saved in a global structure. That might use SoftReferences to avoid memory

problems, still garbage collection doesn't like such actions.


MOP Methods – Dynamic FinderGroovy 3 Uncached


Dynamic Finder in Groovy 3

class GORM {



MopResult methodMissing (String name, args) {


if (method) {



}

return MopResult.of (GroovyInvoker.invoke

(method, delegate, name, args))

}

else return MopResult.ERROR

}

}



class GORM {





if (method) {



}



}


}

}

makes the metaClassstay in memory



class GORM {





if (method) {



}



}


}

}

but not longer than the class GORM


MOP Methods – Dynamic FinderGroovy 3 Cached



class GORM {




{


if (method) {

call.chain (method, delegate, name)

}

else call.error()

}

}

metaClass stays unchanged


Metaclass Versions and Views


Recover old version of a metaclass

class A{}

A.metaClass.foo = {->1}

assert new A().foo() == 1

def oldMetaClass = A.metaClass.freeze()



oldMetaClass.restore()




class A{}








handler for the meta classInstead of the meta class itself



class A{}








make handler keepingcurrent meta class version



class A{}







assert new A().foo() == 1set meta method



class A{}








restore old metaclass version


Some explanations:

■ Before Groovy 3 we always mutate the metaclass

● Recovering an old state is difficult

● Isolating changes almost impossible

■ In Groovy 3 the metaclass is a persistent collection which you can reference by a

handler

● Handler can be set to always give the actual meta class

● Or to “freeze” to keep the actual version and then maybe restore later

In the long term this might actually allow to serialize meta class states


Usage of Realms

class A{}



realm {



}



Usage of Realms

class A{}



realm {



}


create sub realm


Usage of Realms

class A{}



realm {



}


set new meta method


Usage of Realms

class A{}



realm {



}

assert new A().foo() == 1only visible in subrealm


Usage of Realms

class A{}



realm {



} // end of realm


return to parent realm


Some Explanations:

■ A Realm is a set of metaclases separated from the normal program (or parent realm)

at the point of call

■ Changes inside the Realm stay in the Realm and its subrealms

■ Exiting a Realm means to discard all changes done in the Realm

Thought Usage:

● Libraries can isolate code and protect it from outside changes

● Lexicographic Categories


And as always, there is by far not enough time

:(

groovy 3 and the new groovy meta object protocol in examples

Technology