/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 */

/**
 * Refer to pleac.sourceforge.net if wanting accurate comparisons with PERL.
 * Original author has included tweaked examples here solely for the purposes
 * of exercising the Groovy compiler.
 * In some instances, examples have been modified to avoid additional
 * dependencies or for dependencies not in common repos.
 */

import org.hsqldb.jdbc.jdbcDataSource
import groovy.swing.SwingBuilder

// @@PLEAC@@_11.0
//----------------------------------------------------------------------------------
// In Groovy, most usages of names are references (there are some special
// rules for the map shorthand notation and builders).
// Objects are inherently anonymous, they don't know what names refer to them.
ref = 3       // points ref to an Integer object with value 3.
println ref   // prints the value that the name ref refers to.

myList = [3, 4, 5]       // myList is a name for this list
anotherRef = myList
myMap = ["How": "Now", "Brown": "Cow"] // myMap is a name for this map

anArray = [1, 2, 3] as int[] // creates an array of three references to Integer objects

list = [[]]  // a list containing an empty list
list[2] = 'Cat'
println list // => [[], null, "Cat"]
list[0][2] = 'Dog'
println list // => [[null, null, "Dog"], null, "Cat"]

a = [2, 1]
b = a  // b is a reference to the same thing as a
a.sort()
println b // => [1, 2]

nat = [ Name: "Leonhard Euler",
        Address: "1729 Ramanujan Lane\nMathworld, PI 31416",
        Birthday: 0x5bb5580
]
println nat
// =>["Address":"1729 Ramanujan Lane\nMathworld, PI 31416", "Name":"Leonhard Euler", "Birthday":96163200]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.1
//----------------------------------------------------------------------------------
aref = myList
anonList = [1, 3, 5, 7, 9]
anonCopy = anonList
implicitCreation = [2, 4, 6, 8, 10]

anonList += 11
println anonList  // => [1, 3, 5, 7, 9, 11]

two = implicitCreation[0]
assert two == 2

//  To get the last index of a list, you can use size()
// but you never would
lastIdx = aref.size() - 1

// Normally, though, you'd use an index of -1 for the last
// element, -2 for the second last, etc.
println implicitCreation[-1]
//=> 10

// And if you were looping through (and not using a list closure operator)
(0..<aref.size()).each{ /* do something */ }

numItems = aref.size()

assert anArray instanceof int[]
assert anArray.class.isArray()
println anArray

myList.sort() // sort is in place.
myList += "an item" // append item

def createList() { return [] }
aref1 = createList()
aref2 = createList()
// aref1 and aref2 point to different lists.

println anonList[4] // refers to the 4th item in the list_ref list.

// The following two statements are equivalent and return up to 3 elements
// at indices 3, 4, and 5 (if they exist).
x = anonList[3..5]
x = anonList[(3..5).step(1)]

//   This will insert 3 elements, overwriting elements at indices 3,4, or 5 - if they exist.
anonList[3..5] = ["blackberry", "blueberry", "pumpkin"]

// non index-based looping
for (item in anonList) println item
anonList.each{ println it }

// index-based looping
(0..<anonList.size()).each{ idx -> println anonList[idx] }
for (idx in 0..<anonList.size()) println anonList[idx]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.2
//----------------------------------------------------------------------------------
// Making Hashes of Arrays
hash = [:] // empty map
hash["KEYNAME"] = "new value"

hash.each{ key, value -> println key + ' ' + value }

hash["a key"] = [3, 4, 5]
values = hash["a key"]

hash["a key"] += 6
println hash
// => ["KEYNAME":"new value", "a key":[3, 4, 5, 6]]

// attempting to access a value for a key not in the map yields null
assert hash['unknown key'] == null
assert hash.get('unknown key', 45) == 45
println hash
// => ["unknown key":45, "KEYNAME":"new value", "a key":[3, 4, 5, 6]]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.3
//----------------------------------------------------------------------------------
// Hashes are no different to other objects
myHash = [ key1:100, key2:200 ]
myHashCopy = myHash.clone()

value = myHash['key1']
value = myHash.'key1'
slice = myHash[1..3]
keys = myHash.keySet()

assert myHash instanceof Map

[myHash, hash].each{ m ->
    m.each{ k, v -> println "$k => $v"}
}
// =>
// key1 => 100
// key2 => 200
// unknown key => 45
// KEYNAME => new value
// a key => [3, 4, 5, 6]

values = ['key1','key2'].collect{ myHash[it] }
println values  // => [100, 200]

for (key in ["key1", "key2"]) {
    myHash[key] += 7
}
println myHash  // => ["key1":107, "key2":207]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.4
//----------------------------------------------------------------------------------
// you can use closures or the &method notation
def joy() { println 'joy' }
def sullen() { println 'sullen' }
angry = { println 'angry' }
commands = [happy: this.&joy,
            sad:   this.&sullen,
            done:  { System.exit(0) },
            mad:   angry
]

print "How are you?"
cmd = System.in.readLine()
if (cmd in commands.keySet()) commands[cmd]()
else println "No such command: $cmd"


// a counter of the type referred to in the original cookbook
// would be implemented using a class
def counterMaker(){
    def start = 0
    return { -> start++; start-1 }
}

counter = counterMaker()
5.times{ print "${counter()} " }; println()

counter1 = counterMaker()
counter2 = counterMaker()

5.times{ println "${counter1()} " }
println "${counter1()} ${counter2()}"
//=> 0
//=> 1
//=> 2
//=> 3
//=> 4
//=> 5 0


def timestamp() {
    def start = System.currentTimeMillis()
    return { (System.currentTimeMillis() - start).intdiv(1000) }
}
early = timestamp()
//sleep(10000)
later = timestamp()
sleep(2000)
println "It's been ${early()} seconds since early."
println "It's been ${later()} seconds since later."
//=> It's been 12 seconds since early.
//=> It's been 2 seconds since later.
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.5
//----------------------------------------------------------------------------------
// All variables in Groovy are objects including primitives. Some objects
// are immutable. Some operations on objects change mutable objects.
// Some operations produce new objects.

// 15 is an Integer which is an immutable object.
// passing 15 to a method passes a reference to the Integer object.
void print(n) { println "${n.toString()}" }
print(15)  // no need to create any kind of explicit reference

// even though Integers are immutable, references to them are not
x = 1
y = x
println "$x $y"  // => 1 1
x += 1    // "x" now refers to a different object than y
println "$x $y"  // => 2 1
y = 4     // "y" now refers to a different object than it did before
println "$x $y"  // => 2 4

// Some objects (including ints and strings) are immutable, however, which
// can give the illusion of a by-value/by-reference distinction:
list = [[1], 1, 's']
list.each{ it += 1 } // plus operator doesn't operate inplace
print list //=> [[1] 1 s]
list = list.collect{ it + 1 }
print list //=> [[1, 1], 2, s1]

list = [['Z', 'Y', 'X'], ['C', 'B', 'A'], [5, 3, 1]]
list.each{ it.sort() } // sort operation operates inline
println list // => [["X", "Y", "Z"], ["A", "B", "C"], [1, 3, 5]]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.6
//----------------------------------------------------------------------------------
// As indicated by the previous section, everything is referenced, so
// just create a list as normal, and beware that augmented assignment
// works differently with immutable objects to mutable ones and depends
// on the semantics of the particular operation invoked:
mylist = [1, "s", [1]]
print mylist
//=> [1, s, [1]]

mylist.each{ it *= 2 }
print mylist
//=> [1, s, [1,1]]

mylist[0] *= 2
mylist[-1] *= 2
print mylist
//=> [2, s, [1, 1]]

// If you need to modify every value in a list, you use collect
// which does NOT modify inplace but rather returns a new collection:
mylist = 1..4
println mylist.collect{ it**3 * 4/3 * Math.PI }
// => [4.188790204681671, 33.510321638395844, 113.09733552923255, 268.0825731062243]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.7
//----------------------------------------------------------------------------------
def mkcounter(count) {
    def start = count
    def bundle = [:]
    bundle.'NEXT' = { count += 1 }
    bundle.'PREV' = { count -= 1 }
    bundle.'RESET' = { count = start }
    bundle["LAST"] = bundle["PREV"]
    return bundle
}

c1 = mkcounter(20)
c2 = mkcounter(77)

println "next c1: ${c1["NEXT"]()}"  // 21
println "next c2: ${c2["NEXT"]()}"  // 78
println "next c1: ${c1["NEXT"]()}"  // 22
println "last c1: ${c1["PREV"]()}"  // 21
println "last c1: ${c1["LAST"]()}"  // 20
println "old  c2: ${c2["RESET"]()}" // 77
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.8
//----------------------------------------------------------------------------------
def addAndMultiply(a, b) {
    println "${a+b} ${a*b}"
}
methRef = this.&addAndMultiply
// or use direct closure
multiplyAndAdd = { a,b -> println "${a*b} ${a+b}" }
// later ...
methRef(2,3)                   // => 5 6
multiplyAndAdd(2,3)            // => 6 5
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.9
//----------------------------------------------------------------------------------
record = [
    "name": "Jason",
    "empno": 132,
    "title": "deputy peon",
    "age": 23,
    "salary": 37000,
    "pals": ["Norbert", "Rhys", "Phineas"],
]
println "I am ${record.'name'}, and my pals are ${record.'pals'.join(', ')}."
// => I am Jason, and my pals are Norbert, Rhys, Phineas.

byname = [:]
byname[record["name"]] = record

rp = byname.get("Aron")
if (rp) println "Aron is employee ${rp["empno"]}."

byname["Jason"]["pals"] += "Theodore"
println "Jason now has ${byname['Jason']['pals'].size()} pals."

byname.each{ name2, record ->
    println "$name2 is employee number ${record['empno']}."
}

employees = [:]
employees[record["empno"]] = record

// lookup by id
rp = employees[132]
if (rp) println "Employee number 132 is ${rp.'name'}."

byname["Jason"]["salary"] *= 1.035
println record
// => ["pals":["Norbert", "Rhys", "Phineas", "Theodore"], "age":23,
//      "title":"deputy peon", "name":"Jason", "salary":38295.000, "empno":132]

peons = employees.findAll{ k, v -> v.'title' =~ /(?i)peon/ }
assert peons.size() == 1
tsevens = employees.findAll{ k, v -> v.'age' == 27 }
assert tsevens.size() == 0

// Go through all records
println 'Names are: ' + employees.values().collect{r->r.'name'}.join(', ')

byAge = {a,b-> a.value().'age' <=> b.value().'age'}
employees.values().sort{byAge}.each{ r->
    println "${r.'name'} is ${r.'age'}"
}

// byage, a hash: age => list of records
byage = [:]
byage[record["age"]] = byage.get(record["age"], []) + [record]

byage.each{ age, list ->
    println "Age $age: ${list.collect{it.'name'}.join(', ')}"
}
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.10
//----------------------------------------------------------------------------------
// if you are using a Properties (see 8.16) then just use load
// and store (or storeToXML)
// variation to original cookbook as Groovy can use Java's object serialization
map = [1:'Jan', 2:'Feb', 3:'Mar']
// write
new File('months.dat').withObjectOutputStream{ oos ->
    oos.writeObject(map)
}
// reset
map = null
// read
new File('months.dat').withObjectInputStream{ ois ->
    map = ois.readObject()
}
println map // => [1:"Jan", 2:"Feb", 3:"Mar"]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.11
//----------------------------------------------------------------------------------
// Groovy automatically does pretty printing for some of the key types, e.g.
mylist = [[1,2,3], [4, [5,6,7], 8,9, [0,3,5]], 7, 8]
println mylist
// => [[1, 2, 3], [4, [5, 6, 7], 8, 9, [0, 3, 5]], 7, 8]

mydict = ["abc": "def", "ghi":[1,2,3]]
println mydict
// => ["abc":"def", "ghi":[1, 2, 3]]

// if you have another type of object you can use the built-in dump() method
class PetLover {
    def name
    def age
    def pets
}
p = new PetLover(name:'Jason', age:23, pets:[dog:'Rover',cat:'Garfield'])
println p
// => PetLover@b957ea
println p.dump()
// => <PetLover@b957ea name=Jason age=23 pets=["cat":"Garfield", "dog":"Rover"]>

// If that isn't good enough, you can use Boost (http://tara-indigo.org/daisy/geekscape/g2/128)
// or Jakarta Commons Lang *ToStringBuilders (jakarta.apache.org/commons)
// Here's an example of Boost, just extend the supplied Primordial class
//import au.net.netstorm.boost.primordial.Primordial
class Primordial{}
class PetLover2 extends Primordial { def name, age, pets }
println new PetLover2(name:'Jason', age:23, pets:[dog:'Rover',cat:'Garfield'])
// =>
// PetLover2[
//     name=Jason
//     age=23
//     pets={cat=Garfield, dog=Rover}
//     metaClass=groovy.lang.MetaClassImpl@1d8d39f[class PetLover2]
// ]

// using Commons Lang ReflectionToStringBuilder (equivalent to dump())
import org.apache.commons.lang.builder.*
class PetLover3 {
    def name, age, pets
    String toString() {
        ReflectionToStringBuilder.toString(this)
    }
}
println new PetLover3(name:'Jason', age:23, pets:[dog:'Rover',cat:'Garfield'])
// => PetLover3@196e136[name=Jason,age=23,pets={cat=Garfield, dog=Rover}]

// using Commons Lang ToStringBuilder if you want a custom format
class PetLover4 {
    def name, dob, pets
    String toString() {
        def d1 = dob.time; def d2 = (new Date()).time
        int age = (d2 - d1)/1000/60/60/24/365 // close approx good enough here
        return new ToStringBuilder(this).
            append("Pet Lover's name", name).
            append('Pets', pets).
            append('Age', age)
    }
}
println new PetLover4(name:'Jason', dob:new Date(83,03,04), pets:[dog:'Rover',cat:'Garfield'])
// => PetLover4@fdfc58[Pet Lover's name=Jason,Pets={cat=Garfield, dog=Rover},Age=23]
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.12
//----------------------------------------------------------------------------------
oldlist = [1, 2, 3]
newlist = new ArrayList(oldlist) // shallow copy
newlist = oldlist.clone() // shallow copy

oldmap = [a:1, b:2, c:3]
newmap = new HashMap(oldmap) // shallow copy
newmap = oldmap.clone() // shallow copy

oldarray = [1, 2, 3] as int[]
newarray = oldarray.clone()

// shallow copies copy a data structure, but don't copy the items in those
// data structures so if there are nested data structures, both copy and
// original will refer to the same object
mylist = ["1", "2", "3"]
newlist = mylist.clone()
mylist[0] = "0"
println "$mylist $newlist"
//=> ["0", "2", "3"] ["1", "2", "3"]

mylist = [["1", "2", "3"], 4]
newlist = mylist.clone()
mylist[0][0] = "0"
println "$mylist $newlist"
//=> [["0", "2", "3"], 4] [["0", "2", "3"], 4]

// standard deep copy implementation
def deepcopy(orig) {
     bos = new ByteArrayOutputStream()
     oos = new ObjectOutputStream(bos)
     oos.writeObject(orig); oos.flush()
     bin = new ByteArrayInputStream(bos.toByteArray())
     ois = new ObjectInputStream(bin)
     return ois.readObject()
}

newlist = deepcopy(oldlist) // deep copy
newmap  = deepcopy(oldmap)  // deep copy

mylist = [["1", "2", "3"], 4]
newlist = deepcopy(mylist)
mylist[0][0] = "0"
println "$mylist $newlist"
//=> [["0", "2", "3"], 4] [["1", "2", "3"], 4]

// See also:
// http://javatechniques.com/public/java/docs/basics/low-memory-deep-copy.html
// http://javatechniques.com/public/java/docs/basics/faster-deep-copy.html
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.13
//----------------------------------------------------------------------------------
// use Java's serialization capabilities as per 11.10
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.14
//----------------------------------------------------------------------------------
// There are numerous mechanisms for persisting objects to disk
// using Groovy and Java mechanisms. Some are completely transparent,
// some require some initialization only, others make the persistence
// mechanisms visible. Here is a site that lists over 20 options:
// http://www.java-source.net/open-source/persistence
// (This list doesn't include EJB offerings which typically
// require an application server or XML-based options)

// We'll just consider one possibility from prevayler.sf.net.
// This package doesn't make changes to persistent data transparent;
// instead requiring an explicit call via a transaction object.
// It saves all such transaction objects in a journal file so
// that it can rollback the system any number of times (or if
// you make use of the timestamp feature) to a particular point
// in time. It can also be set up to create snapshots which
// consolidate all changes made up to a certain point. The
// journaling will begin again from that point.
import org.prevayler.*
class ImportantHash implements Serializable {
    private map = [:]
    def putAt(key, value) { map[key] = value }
    def getAt(key) { map[key] }
}
class StoreTransaction implements Transaction {
    private v
    StoreTransaction(val) { this.v = val }
    void executeOn(prevayler, Date ignored) { prevayler.putAt(v,v*2) }
}
def save(n){ store.execute(new StoreTransaction(n)) }
store = PrevaylerFactory.createPrevayler(new ImportantHash(), "pleac11")
hash = store.prevalentSystem()
for (i in 0..1000) {
    save(i)
}
println hash[750] // => 1500

store = null; hash = null // *** could shutdown here

store = PrevaylerFactory.createPrevayler(new ImportantHash(), "pleac11")
hash = store.prevalentSystem()
println hash[750] // => 1500
//----------------------------------------------------------------------------------


// @@PLEAC@@_11.15
//----------------------------------------------------------------------------------
// bintree - binary tree demo program
class BinaryTree {
    def value, left, right
    BinaryTree(val) {
        value = val
        left = null
        right = null
    }

    // insert given value into proper point of
    // provided tree.  If no tree provided,
    // use implicit pass by reference aspect of @_
    // to fill one in for our caller.
    def insert(val) {
        if (val < value) {
            if (left) left.insert(val)
            else left = new BinaryTree(val)
        } else if (val > value) {
            if (right) right.insert(val)
            else right = new BinaryTree(val)
        } else println "double" // ignore double values
    }

    // recurse on left child,
    // then show current value,
    // then recurse on right child.
    def inOrder() {
        if (left) left.inOrder()
        print value + ' '
        if (right) right.inOrder()
    }

    // show current value,
    // then recurse on left child,
    // then recurse on right child.
    def preOrder() {
        print value + ' '
        if (left) left.preOrder()
        if (right) right.preOrder()
    }

    // show current value,
    // then recurse on left child,
    // then recurse on right child.
    def dumpOrder() {
        print this.dump() + ' '
        if (left) left.dumpOrder()
        if (right) right.dumpOrder()
    }

    // recurse on left child,
    // then recurse on right child,
    // then show current value.
    def postOrder() {
        if (left) left.postOrder()
        if (right) right.postOrder()
        print value + ' '
    }

    // find out whether provided value is in the tree.
    // if so, return the node at which the value was found.
    // cut down search time by only looking in the correct
    // branch, based on current value.
    def search(val) {
        if (val == value) {
            return this.dump()
        } else if (val < value) {
            return left ? left.search(val) : null
        } else {
            return right ? right.search(val) : null
        }
    }
}

// first generate 20 random inserts
test = new BinaryTree(500)
rand = new Random()
20.times{
    test.insert(rand.nextInt(1000))
}

// now dump out the tree all three ways
print "Pre order:  "; test.preOrder();  println ""
print "In order:   "; test.inOrder();   println ""
print "Post order: "; test.postOrder(); println ""

println "\nSearch?"
while ((item = System.in.readLine()?.trim()) != null) {
    println test.search(item.toInteger())
    println "\nSearch?"
}
// Randomly produces a tree such as:
//           -------- 500 ------
//         /                     \
//       181                     847
//     /    \                    /  \
//   3       204              814   970
//    \       /  \            /
//    126  196  414        800
//             /   \       /
//          353   438   621
//                /     /  \
//             423    604   776
//                   /     /
//                 517   765
//                      /
//                    646
//                   /
//                 630
// Pre order:
// 500 181 3 126 204 196 414 353 438 423 847 814 800 621 604 517 776 765 646 630 970
// In order:
// 3 126 181 196 204 353 414 423 438 500 517 604 621 630 646 765 776 800 814 847 970
// Post order:
// 126 3 196 353 423 438 414 204 181 517 604 630 646 765 776 621 800 814 970 847 500
//
// Search?
// 125
// null
//
// Search?
// 126
// <BinaryTree@ae97c4 value=126 left=null right=null>
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.0
//----------------------------------------------------------------------------------
// Groovy adopts many of the Java structuring conventions and terminology
// and adds some concepts of its own.
// Code-reuse can occur at the script, class, library, component or framework level.
// Source code including class file source and scripts are organised into packages.
// These can be thought of as like hierarchical folders or directories. Two class
// with the same name can be distinguished by having different packages. Compiled
// byte code and sometimes source code including scripts can be packaged up into
// jar files. Various conventions exist for packaging classes and resources in
// such a way to allow them to be easily reused. Some of these conventions allow
// reusable code to be placed within repositories for easy use by third parties.
// One such repository is the maven repository, e.g.: ibiblio.org/maven2
// When reusing classes, it is possible to compartmentalise knowledge of
// particular packages using multiple (potentially hierarchical) classloaders.
// By convention, package names are all lowercase. Class names are capitalized.
// Naming examples:
// package my.package1.name     // at most one per source file - at top of file
// class MyClass ...            // actually defines my.package1.name.MyClass
// import my.package1.name.MyClass  // allows package to be dropped within current file
// import my.package2.name.MyClass  // if class basenames are the same, can't
//                                  // import both, leave one fully qualified
// import my.package.name.*         // all classes in package can drop package prefix
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.1
//----------------------------------------------------------------------------------
// No equivalent export process exists for Groovy.

// If you have some Groovy functionality that you would like others to use
// you either make the source code available or compile it into class files
// and package those up in a jar file. Some subset of your class files will
// define the OO interface to your functionality, e.g. public methods,
// interfaces, etc. Depending on the circumstances, various conventions are
// used to indicate this functionality including Manifest files, javadocs,
// deployment descriptors, project metadata and dependency management files.
// See 12.18 for an example.
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.2
//----------------------------------------------------------------------------------
// Groovy supports both static and dynamic (strong) typing. When trying to
// compile or run files using static typing, the required classes referenced
// must be available. Classes used in more dynamic ways may be loaded (or
// created) at runtime. Errors in loading such dynamic cases are handled
// using the normal exception handling mechanisms.

// attempt to load an unknown resource or script:
try {
    evaluate(new File('doesnotexist.groovy'))
} catch (Exception FileNotFoundException) {
    println 'File not found, skipping ...'
}
// => File not found, skipping ...

// attempt to load an unknown class:
try {
    Class.forName('org.happytimes.LottoNumberGenerator')
} catch (ClassNotFoundException ex) {
    println 'Class not found, skipping ...'
}
// -> Class not found, skipping ...

// dynamicallly look for a database driver (slight variation to original cookbook)
// Note: this hypothetical example ignores certain issues e.g. different url
// formats for configuration when establishing a connection with the driver
candidates = [
    'oracle.jdbc.OracleDriver',
    'com.ibm.db2.jcc.DB2Driver',
    'com.microsoft.jdbc.sqlserver.SQLServerDriver',
    'net.sourceforge.jtds.jdbc.Driver',
    'com.sybase.jdbc3.jdbc.SybDriver',
    'com.informix.jdbc.IfxDriver',
    'com.mysql.jdbc.Driver',
    'org.postgresql.Driver',
    'com.sap.dbtech.jdbc.DriverSapDB',
    'org.hsqldb.jdbcDriver',
    'com.pointbase.jdbc.jdbcUniversalDriver',
    'org.apache.derby.jdbc.ClientDriver',
    'com.mckoi.JDBCDriver',
    'org.firebirdsql.jdbc.FBDriver',
    'sun.jdbc.odbc.JdbcOdbcDriver'
]
loaded = null
for (driver in candidates) {
    try {
        loaded = Class.forName(driver).newInstance()
        break
    } catch (Exception ex) { /* ignore */ }
}
println loaded?.class?.name // => sun.jdbc.odbc.JdbcOdbcDriver
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.3
//----------------------------------------------------------------------------------
// In Groovy (like Java), any static reference to an external class within
// your class will cause the external class to be loaded from the classpath.
// You can dynamically add to the classpath using:
// this.class.rootLoader.addURL(url)
// To delay loading of external classes, use Class.forName() or evaluate()
// the script separately as shown in 12.2.

// For the specific case of initialization code, here is another example:
// (The code within the anonymous { ... } block is called whenever the
// class is loaded.)
class DbHelper {
    def driver
    {
        if (System.properties.'driver' == 'oracle')
            driver = Class.forName('oracle.jdbc.OracleDriver')
        else
            driver = Class.forName('sun.jdbc.odbc.JdbcOdbcDriver')
    }
}
println new DbHelper().driver.name // => sun.jdbc.odbc.JdbcOdbcDriver
// call program with -Ddriver=oracle to swap to other driver

// A slightly related feature: If you want to load a script (typically in a
// server environment) whenever the source file changes, use GroovyScriptEngine()
// instead of GroovyShell() when embedding groovy.
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.4
//----------------------------------------------------------------------------------
// class variables are private unless access functions are defined
class Alpha {
    def x = 10
    private y = 12
}

println new Alpha().x    // => 10
println new Alpha().y    // => 12 when referenced inside source file, error outside
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.5
//----------------------------------------------------------------------------------
// You can examine the stacktrace to determine the calling class: see 10.4
// When executing a script from a groovy source file, you can either:
println getClass().classLoader.resourceLoader.loadGroovySource(getClass().name)
// => file:/C:/Projects/GroovyExamples/Pleac/classes/pleac12.groovy
// or for the initially started script when started using the standard .bat/.sh files
println System.properties.'script.name'
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.6
//----------------------------------------------------------------------------------
// For code which executes at class startup, see the initialization code block
// mechanism mentioned in 12.3. For code which should execute during shutdown
// see the finalize() method discussed (including limitations) in 13.2.
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.7
//----------------------------------------------------------------------------------
// Each JVM process may have its own classpath (and indeed its own version of Java
// runtime and libraries). You "simply" supply a classpath pointing to different
// locations to obtain different modules.
// Groovy augments the JVM behaviour by allowing individuals to have a ~/.groovy/lib
// directory with additional libraries (and potentially other resources).
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.8
//----------------------------------------------------------------------------------
// To make your code available to others could involve any of the following:
// (1) make your source code available
// (2) if you are creating a standard class, use the jar tool to package the
//     compiled code into a jar - this is then added to the classpath to use
// (3) if the jar relies on additional jars, this is sometimes specified in
//     a special manifest file within the jar
// (4) if the code is designed to run within a container environment, there
//     might be additional packaging, e.g. servlets might be packaged in a war
//     file - essentially a jar file with extra metadata in xml format.
// (5) you might also supply your package to a well known repository such as the
//     maven repository - and you will add dependency information in xml format
// (6) you may use platform specific installers to produce easily installable
//     components (e.g. windows .exe files or linux rpm's)
// (7) you may spackage up your components as a plugin (e.g. as an eclipse plugin)
//     this is also typically in jar/zip like format with additional metadata
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.9
//----------------------------------------------------------------------------------
// Groovy has no SelfLoader. Class loading can be delayed using external scripts
// and by using the Class.forName() approach discussed in 12.2/12.3. If you have
// critical performance issues, you can use these techniques and keep your class
// size small to maximise the ability to defer loading. There are other kinds of
// performance tradeoffs you can make too. Alot of work has been done with JIT
// (just in time) compilers for bytecode. You can pre-compile Groovy source files
// into bytecode using the groovy compiler (groovyc). You can also do this on
// the fly for scripts you know you are going to need shortly.
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.10
//----------------------------------------------------------------------------------
// Groovy has no AutoLoader. See the discussion in 12.9 for some techniques to
// impact program performance. There are many techniques available to speed up
// program performance (and in particular load speed). Some of these utilise
// techniques similar in nature to the technique used by the AutoLoader.
// As already mentioned, when you load a class into the JVM, any statically
// referenced class is also loaded. If you reference interfaces rather than
// concrete implementations, only the interface need be loaded. If you must
// reference a concrete implementation you can use either a Proxy class or
// classloader tricks to delay the loading of a full class (e.g. you supply a
// Proxy class with just one method implemented or a lazy-loading Proxy which
// loads the real class only when absolutely required)
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.11
//----------------------------------------------------------------------------------
// You can use Categories to override Groovy and Java base functionality.
println new Date().time // => 1169019557140

class DateCategory2 {  // the class name by convention ends with category
    // we can add new functionality
    static float getFloatTime(Date self) {
        return (float) self.getTime()
    }
    // we can override existing functionality (now seconds since 1970 not millis)
    static long asSeconds(Date self) {
        return (long) (self.getTime()/1000)
    }
}

use (DateCategory2) {
    println new Date().floatTime    // => 1.1690195E12
    println new Date().asSeconds()  // => 1169019557
}

// We can also use the 'as' keyword
class MathLib {
    def triple(n) { n * 4 }
    def twice(n) { n * 2 }
}
def m = new MathLib()
println m.twice(10)     // => 20
println m.triple(10)    // => 40 (Intentional Bug!)
// we might want to make use of some funtionality in the math
// library but want to later some of its features slightly or fix
// some bugs, we can simply import the original using a different name
import MathLib as BuggyMathLib
// now we could define our own MathLib which extended or had a delegate
// of the BuggyMathLib class
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.12
//----------------------------------------------------------------------------------
// Many Java and Groovy programs emit a stacktrace when an error occurs.
// This shows both the calling and called programs (with line numbers if
// supplied). Groovy pretties up stacktraces to show less noise. You can use -d
// or --debug on the commandline to force it to always produce full stacktraces.
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.13
//----------------------------------------------------------------------------------
// already have log10, how to create log11 to log100
(11..100).each { int base ->
    binding."log$base" = { int n -> Math.log(n) / Math.log(base) }
}
println log20(400)  // => 2.0
println log100(1000000)  // => 3.0 (displays 2.9999999999999996 using doubles)

// same thing again use currying
def logAnyBase = { base, n -> Math.log(n) / Math.log(base) }
(11..100).each { int base ->
    binding."log$base" = logAnyBase.curry(base)
}
println log20(400)  // => 2.0
println log100(1000000)  // => 3.0 (displays 2.9999999999999996 using doubles)
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.14
//----------------------------------------------------------------------------------
// Groovy intefaces with C in the same way as Java: using JNI
// For this discussion we will ignoring platform specific options and CORBA.
// This tutorial here describes how to allow Java (and hence Groovy) to
// call a C program which generates UUIDs:
// http://ringlord.com/publications/jni-howto/
// Here's another useful reference:
// http://weblogs.java.net/blog/kellyohair/archive/2006/01/compilation_of_1.html
// And of course, Sun's tutorial:
// http://java.sun.com/developer/onlineTraining/Programming/JDCBook/jni.html

// You might also want to consider SWIG which simplifies connecting
// C/C++ to many scripting languages including Java (and hence Groovy)
// More details: http://www.swig.org/
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.15
//----------------------------------------------------------------------------------
// See discussion for 12.14
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.16
//----------------------------------------------------------------------------------
// The standard documentation system for Java is JavaDoc.
// Documentation for JavaDoc is part of a Java installation.
// Groovy has a GroovyDoc tool planned which expands upon the JavaDoc tool
// but work on the tool hasn't progressed much as yet.
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.17
//----------------------------------------------------------------------------------
// Most libraries for Java (and hence Groovy) come precompiled. You simply download
// the jar and place it somewhere on your CLASSPATH.

// If only source code is available, you need to download the source and follow any
// instuctions which came with the source. Most projects use one of a handful of
// build tools to compile, test and package their artifacts. Typical ones are Ant
// and Maven which you need to install according to their respective instructions.

// If using Ant, you need to unpack the source files then type 'ant'.

// If using Maven, you need to unpack the source files then type 'maven'.

// If you are using Maven or Ivy for dependency management you can add
// the following lines to your project description file.
/*
    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.2</version>
    </dependency>
*/
// This will automatically download the particular version of the referenced
// library file and also provide hooks so that you can make this automatically
// available in your classpath.
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.18
//----------------------------------------------------------------------------------
// example groovy file for a "module"
//import org.apache.commons.lang.WordUtils
class WordUtils{}
class GroovyTestCase{}

class Greeter {
    def name
    Greeter(who) { name = WordUtils.capitalize(who) }
    def salute() { "Hello $name!" }
}

// test class
class GreeterTest extends GroovyTestCase {
    def testGreeting() {
        assert new Greeter('world').salute()
    }
}

// Typical Ant build file (could be in Groovy instead of XML):
/*
<?xml version="1.0"?>
<project name="sample" default="jar" basedir=".">
    <property name="src" value="src"/>
    <property name="build" value="build"/>

    <target name="init">
        <mkdir dir="${build}"/>
    </target>

    <target name="compile" depends="init">
        <mkdir dir="${build}/classes"/>
        <groovyc srcdir="${src}" destdir="${build}/classes"/>
    </target>

    <target name="test" depends="compile">
        <groovy src="${src}/GreeterTest.groovy">
    </target>

    <target name="jar" depends="compile,test">
        <mkdir dir="${build}/jar"/>
        <jar destfile="${build}/jar/Greeter.jar" basedir="${build}/classes">
            <manifest>
                <attribute name="Main-Class" value="Greeter"/>
            </manifest>
        </jar>
    </target>
</project>

*/

// Typical dependency management file
/*
<?xml version="1.0" encoding="UTF-8"?>
<project
  xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
          http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>groovy</groupId>
  <artifactId>module</artifactId>
  <name>Greeter</name>
  <version>1.0</version>
  <packaging>jar</packaging>
  <description>Greeter Module/description>
  <dependencies>
    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.2</version>
    </dependency>
  </dependencies>
</project>
*/
//----------------------------------------------------------------------------------


// @@PLEAC@@_12.19
//----------------------------------------------------------------------------------
// Searching available modules in repositories:
// You can browse the repositories online, e.g. ibiblio.org/maven2 or various
// plugins are available for IDEs which do this for you, e.g. JarJuggler for IntelliJ.

// Searching currently "installed" modules:
// Browse your install directory, view your maven POM file, look in your ~/.groovy/lib
// directory, turn on debug modes and watch classloader messages ...
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.0
//----------------------------------------------------------------------------------
// Classes and objects in Groovy are rather straigthforward
class Person2 {
    // Class variables (also called static attributes) are prefixed by the keyword static
    static personCounter=0
    def age, name               // this creates setter and getter methods
    private alive

    // object constructor
    Person2(age, name, alive = true) {            // Default arg like in C++
        this.age = age
        this.name = name
        this.alive = alive
        personCounter += 1
        // There is a '++' operator in Groovy but using += is often clearer.
    }

    def die() {
        alive = false
        println "$name has died at the age of $age."
        alive
    }

    def kill(anotherPerson) {
        println "$name is killing $anotherPerson.name."
        anotherPerson.die()
    }

    // methods used as queries generally start with is, are, will or can
    // usually have the '?' suffix
    def isStillAlive() {
        alive
    }

    def getYearOfBirth() {
        new Date().year - age
    }

    // Class method (also called static method)
    static getNumberOfPeople() { // accessors often start with get
                                 // in which case you can call it like
                                 // it was a field (without the get)
        personCounter
    }
}

// Using the class:
// Create objects of class Person
lecter = new Person2(47, 'Hannibal')
starling = new Person2(29, 'Clarice', true)
pazzi = new Person2(40, 'Rinaldo', true)

// Calling a class method
println "There are $Person2.numberOfPeople Person objects."

println "$pazzi.name is ${pazzi.alive ? 'alive' : 'dead'}."
lecter.kill(pazzi)
println "$pazzi.name is ${pazzi.isStillAlive() ? 'alive' : 'dead'}."

println "$starling.name was born in $starling.yearOfBirth."
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.1
//----------------------------------------------------------------------------------
// Classes may have no constructor.
class MyClass { }

aValidButNotVeryUsefulObject = new MyClass()

// If no explicit constructor is given a default implicit
// one which supports named parameters is provided.
class MyClass2 {
    def start = new Date()
    def age = 0
}
println new MyClass2(age:4).age // => 4

// One or more explicit constructors may also be provided
class MyClass3 {
    def start
    def age
    MyClass3(date, age) {
        start = date
        this.age = age
    }
}
println new MyClass3(new Date(), 20).age // => 20
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.2
//----------------------------------------------------------------------------------
// Objects are destroyed by the JVM garbage collector.
// The time of destroying is not predicated but left up to the JVM.
// There is no direct support for destructor. There is a courtesy
// method called finalize() which the JVM may call when disposing
// an object. If you need to free resources for an object, like
// closing a socket or killing a spawned subprocess, you should do
// it explicitly - perhaps by supporting your own lifecycle methods
// on your class, e.g. close().

class MyClass4{
    void finalize() {
        println "Object [internal id=${hashCode()}] is dying at ${new Date()}"
    }
}

// test code
50.times {
    new MyClass4()
}
20.times {
    System.gc()
}
// => (between 0 and 50 lines similar to below)
// Object [internal id=10884088] is dying at Wed Jan 10 16:33:33 EST 2007
// Object [internal id=6131844] is dying at Wed Jan 10 16:33:33 EST 2007
// Object [internal id=12245160] is dying at Wed Jan 10 16:33:33 EST 2007
// ...
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.3
//----------------------------------------------------------------------------------
// You can write getter and setter methods explicitly as shown below.
// One convention is to use set and get at the start of method names.
class Person2B {
    private name
    def getName() { name }
    def setName(name) { this.name = name }
}

// You can also just use def which auto defines default getters and setters.
class Person3 {
    def age, name
}

// Any variables marked as final will only have a default getter.
// You can also write an explicit getter. For a write-only variable
// just write only a setter.
class Person4 {
    final age      // getter only
    def name       // getter and setter
    private color  // private
    def setColor() { this.color = color } // setter only
}
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.4
//----------------------------------------------------------------------------------
class Person5 {
    // Class variables (also called static attributes) are prefixed by the keyword static
    static personCounter = 0

    static getPopulation() {
        personCounter
    }
    Person5() {
        personCounter += 1
    }
    void finalize() {
        personCounter -= 1
    }
}
people = []
10.times {
    people += new Person5()
}
println "There are ${Person5.population} people alive"
// => There are 10 people alive

alpha = new FixedArray()
println "Bound on alpha is $alpha.maxBounds"

beta = new FixedArray()
beta.maxBounds = 50
println "Bound on alpha is $alpha.maxBounds"

class FixedArray {
    static maxBounds = 100

    def getMaxBounds() {
        maxBounds
    }
    def setMaxBounds(value) {
        maxBounds = value
    }
}
// =>
// Bound on alpha is 100
// Bound on alpha is 50
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.5
//----------------------------------------------------------------------------------
// The fields of this struct-like class are dynamically typed
class DynamicPerson { def name, age, peers }
p = new DynamicPerson()
p.name = "Jason Smythe"
p.age = 13
p.peers = ["Wilbur", "Ralph", "Fred"]
p.setPeers(["Wilbur", "Ralph", "Fred"])     // alternative using implicit setter
p["peers"] = ["Wilbur", "Ralph", "Fred"]    // alternative access using name of field
println "At age $p.age, $p.name's first friend is ${p.peers[0]}"
// => At age 13, Jason Smythe's first friend is Wilbur

// The fields of this struct-like class are statically typed
class StaticPerson { String name; int age; List peers }
p = new StaticPerson(name:'Jason', age:14, peers:['Fred','Wilbur','Ralph'])
println "At age $p.age, $p.name's first friend is ${p.peers[0]}"
// => At age 14, Jason's first friend is Fred


class Family { def head, address, members }
folks = new Family(head:new DynamicPerson(name:'John',age:34))

// supply of own accessor method for the struct for error checking
class ValidatingPerson {
    private age
    def printAge() { println 'Age=' + age }
    def setAge(value) {
        if (!(value instanceof Integer))
            throw new IllegalArgumentException("Argument '${value}' isn't an Integer")
        if (value > 150)
            throw new IllegalArgumentException("Age ${value} is unreasonable")
        age = value
    }
}

// test ValidatingPerson
def tryCreate(arg) {
    try {
        new ValidatingPerson(age:arg).printAge()
    } catch (Exception ex) {
        println ex.message
    }
}

tryCreate(20)
tryCreate('Youngish')
tryCreate(200)
// =>
// Age=20
// Argument 'Youngish' isn't an Integer
// Age 200 is unreasonable
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.6
//----------------------------------------------------------------------------------
// Groovy objects are (loosely speaking) extended Java objects.
// Java's Object class provides a clone() method. The conventions of
// clone() are that if I say a = b.clone() then a and b should be
// different objects with the same type and value. Java doesn't
// enforce a class to implement a clone() method at all let alone
// require that one has to meet these conventions. Classes which
// do support clone() should implement the Cloneable interface and
// implement an equals() method.
// Groovy follows Java's conventions for clone().

class A implements Cloneable {
    def name
    boolean equals(Object other) {
        other instanceof A && this.name == other.name
    }
}
ob1 = new A(name:'My named thing')

ob2 = ob1.clone()
assert !ob1.is(ob2)
assert ob1.class == ob2.class
assert ob2.name == ob1.name
assert ob1 == ob2
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.7
//----------------------------------------------------------------------------------
class CanFlicker {
    def flicker(arg) { return arg * 2 }
}
methname = 'flicker'
assert new CanFlicker().invokeMethod(methname, 10) == 20
assert new CanFlicker()."$methname"(10) == 20

class NumberEcho {
    def one() { 1 }
    def two() { 2 }
    def three() { 3 }
}
obj = new NumberEcho()
// call methods on the object, by name
assert ['one', 'two', 'three', 'two', 'one'].collect{ obj."$it"() }.join() == '12321'
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.8
//----------------------------------------------------------------------------------
// Groovy can work with Groovy objects which inherit from a common base
// class called GroovyObject or Java objects which inherit from Object.

// the class of the object
assert 'a string'.class == java.lang.String

// Groovy classes are actually objects of class Class and they
// respond to methods defined in the Class class as well
assert 'a string'.class.class == java.lang.Class
assert !'a string'.class.isArray()

// ask an object whether it is an instance of particular class
n = 4.7f
println (n instanceof Integer)          // false
println (n instanceof Float)            // true
println (n instanceof Double)           // false
println (n instanceof String)           // false
println (n instanceof StaticPerson)     // false

// ask if a class or interface is either the same as, or is a
// superclass or superinterface of another class
println n.class.isAssignableFrom(Float.class)       // true
println n.class.isAssignableFrom(String.class)      // false

// can a Groovy object respond to a particular method?
assert new CanFlicker().metaClass.methods*.name.contains('flicker')

class POGO{}
println (obj.metaClass.methods*.name - new POGO().metaClass.methods*.name)
// => ["one", "two", "three"]
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.9
//----------------------------------------------------------------------------------
// Most classes in Groovy are inheritable
class Person6{ def age, name }
dude = new Person6(name:'Jason', age:23)
println "$dude.name is age $dude.age."

// Inheriting from Person
class Employee2B extends Person6 {
    def salary
}
empl = new Employee2B(name:'Jason', age:23, salary:200)
println "$empl.name is age $empl.age and has salary $empl.salary."

// Many built-in class can be inherited the same way
class WierdList extends ArrayList {
    int size() {  // size method in this class is overridden
        super.size() * 2
    }
}
a = new WierdList()
a.add('dog')
a.add('cat')
println a.size() // => 4
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.10
//----------------------------------------------------------------------------------
class Person7 { def firstname, surname; def getName(){ firstname + ' ' + surname } }
class Employee2 extends Person7 {
    def employeeId
    def getName(){ 'Employee Number ' + employeeId }
    def getRealName(){ super.getName() }
}
p = new Person7(firstname:'Jason', surname:'Smythe')
println p.name
// =>
// Jason Smythe
e = new Employee2(firstname:'Jason', surname:'Smythe', employeeId:12349876)
println e.name
println e.realName
// =>
// Employee Number 12349876
// Jason Smythe
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.11
//----------------------------------------------------------------------------------
// Groovy's built in constructor and auto getter/setter features
 // give you the required functionalty already but you could also
 // override invokeMethod() for trickier scenarios.
class Person8 {
    def name, age, peers, parent
    def newChild(args) { new Person8(parent:this, *:args) }
}

dad = new Person8(name:'Jason', age:23)
kid = dad.newChild(name:'Rachel', age:2)
println "Kid's parent is ${kid.parent.name}"
// => Kid's parent is Jason

// additional fields ...
class Employee3 extends Person8 { def salary, boss }
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.12
//----------------------------------------------------------------------------------
// Fields marked as private in Groovy can't be trampled by another class in
// the class hierarchy
class Parent2 {
    private name // my child's name
    def setChildName(value) { name = value }
    def getChildName() { name }
}
class GrandParent extends Parent2 {
    private name // my grandchild's name
    def setgrandChildName(value) { name = value }
    def getGrandChildName() { name }
}
g = new GrandParent()
g.childName = 'Jason'
g.grandChildName = 'Rachel'
println g.childName       // => Jason
println g.grandChildName  // => Rachel
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.13
//----------------------------------------------------------------------------------
// The JVM garbage collector copes with circular structures.
// You can test it with this code:
class Person9 {
    def friend
    void finalize() {
        println "Object [internal id=${hashCode()}] is dying at ${new Date()}"
    }
}

def makeSomeFriends() {
    def first = new Person9()
    def second = new Person9(friend:first)
    def third = new Person9(friend:second)
    def fourth = new Person9(friend:third)
    def fifth = new Person9(friend:fourth)
    first.friend = fifth
}

makeSomeFriends()
100.times{
    System.gc()
}
// =>
// Object [internal id=24478976] is dying at Tue Jan 09 22:24:31 EST 2007
// Object [internal id=32853087] is dying at Tue Jan 09 22:24:31 EST 2007
// Object [internal id=23664622] is dying at Tue Jan 09 22:24:31 EST 2007
// Object [internal id=10630672] is dying at Tue Jan 09 22:24:31 EST 2007
// Object [internal id=25921812] is dying at Tue Jan 09 22:24:31 EST 2007
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.14
//----------------------------------------------------------------------------------
// Groovy provides numerous methods which are automatically associated with
// symbol operators, e.g. here is '<=>' which is associated with compareTo()
// Suppose we have a class with a compareTo operator, such as:
class Person10 implements Comparable {
    def firstname, initial, surname
    Person10(f,i,s) { firstname = f; initial = i; surname = s }
    int compareTo(other) { firstname <=> other.firstname }
}
a = new Person10('James', 'T', 'Kirk')
b = new Person10('Samuel', 'L', 'Jackson')
println a <=> b
// => -1

// we can override the existing Person10's <=> operator as below
// so that now comparisons are made using the middle initial
// instead of the fisrtname:
class Person11 extends Person10 {
    Person11(f,i,s) { super(f,i,s) }
    int compareTo(other) { initial <=> other.initial }
}

a = new Person11('James', 'T', 'Kirk')
b = new Person11('Samuel', 'L', 'Jackson')
println a <=> b
// => 1

// we could also in general use Groovy's categories to extend class functionality.

// There is no way to directly overload the '""' (stringify)
// operator in Groovy.  However, by convention, classes which
// can reasonably be converted to a String will define a
// 'toString()' method as in the TimeNumber class defined below.
// The 'println' method will automatcally call an object's
// 'toString()' method as is demonstrated below. Furthermore,
// an object of that class can be used most any place where the
// interpreter is looking for a String value.

//---------------------------------------
// NOTE: Groovy has various built-in Time/Date/Calendar classes
// which would usually be used to manipulate time objects, the
// following is supplied for educational purposes to demonstrate
// operator overloading.
class TimeNumber {
    def h, m, s
    TimeNumber(hour, min, sec) { h = hour; m = min; s = sec }

    def toDigits(s) { s.toString().padLeft(2, '0') }
    String toString() {
        return toDigits(h) + ':' + toDigits(m) + ':' + toDigits(s)
    }

    def plus(other) {
        s = s + other.s
        m = m + other.m
        h = h + other.h
        if (s >= 60) {
            s %= 60
            m += 1
        }
        if (m >= 60) {
            m %= 60
            h += 1
        }
        return new TimeNumber(h, m, s)
    }

}

t1 = new TimeNumber(0, 58, 59)
sec = new TimeNumber(0, 0, 1)
min = new TimeNumber(0, 1, 0)
println t1 + sec + min + min

//-----------------------------
// StrNum class example: Groovy's builtin String class already has the
// capabilities outlined in StrNum Perl example, however the '*' operator
// on Groovy's String class acts differently: It creates a string which
// is the original string repeated N times.
//
// Using Groovy's String class as is in this example:
x = "Red"; y = "Black"
z = x+y
r = z*3 // r is "RedBlackRedBlackRedBlack"
println "values are $x, $y, $z, and $r"
println "$x is ${x < y ? 'LT' : 'GE'} $y"
// prints:
// values are Red, Black, RedBlack, and RedBlackRedBlackRedBlack
// Red is GE Black

//-----------------------------
class FixNum {
    def REGEX = /(\.\d*)/
    static final DEFAULT_PLACES = 0
    def float value
    def int places
    FixNum(value) {
        initValue(value)
        def m = value.toString() =~ REGEX
        if (m) places = m[0][1].size() - 1
        else places = DEFAULT_PLACES
    }
    FixNum(value, places) {
        initValue(value)
        this.places = places
    }
    private initValue(value) {
        this.value = value
    }

    def plus(other) {
        new FixNum(value + other.value, [places, other.places].max())
    }

    def multiply(other) {
        new FixNum(value * other.value, [places, other.places].max())
    }

    def div(other) {
        println "DEUG: Divide = ${value/other.value}"
        def result = new FixNum(value/other.value)
        result.places = [places,other.places].max()
        result
    }

    String toString() {
        //m = value.toString() =~ /(\d)/ + REGEX
        String.format("STR%s: %.${places}f", [this.class.name, value as float] as Object[])
    }
}

x = new FixNum(40)
y = new FixNum(12, 0)

println "sum of $x and $y is ${x+y}"
println "product of $x and $y is ${x*y}"

z = x/y
println "$z has $z.places places"
z.places = 2
println "$z now has $z.places places"

println "div of $x by $y is $z"
println "square of that is ${z*z}"
// =>
// sum of STRFixNum: 40 and STRFixNum: 12 is STRFixNum: 52
// product of STRFixNum: 40 and STRFixNum: 12 is STRFixNum: 480
// DEUG: Divide = 3.3333333333333335
// STRFixNum: 3 has 0 places
// STRFixNum: 3.33 now has 2 places
// div of STRFixNum: 40 by STRFixNum: 12 is STRFixNum: 3.33
// square of that is STRFixNum: 11.11
//----------------------------------------------------------------------------------


// @@PLEAC@@_13.15
//----------------------------------------------------------------------------------
// Groovy doesn't use the tie terminology but you can achieve
// similar results with Groovy's metaprogramming facilities
class ValueRing {
    private values
    def add(value) { values.add(0, value) }
    def next() {
        def head = values[0]
        values = values[1..-1] + head
        return head
    }
}
ring = new ValueRing(values:['red', 'blue'])
def getColor() { ring.next() }
void setProperty(String n, v) {
    if (n == 'color') { ring.add(v); return }
    super.setProperty(n,v)
}

println "$color $color $color $color $color $color"
// => red blue red blue red blue

color = 'green'
println "$color $color $color $color $color $color"
// => green red blue green red blue

// Groovy doesn't have the $_ implicit variable so we can't show an
// example that gets rid of it. We can however show an example of how
// you could add in a simplified version of that facility into Groovy.
// We use Groovy's metaProgramming facilities. We execute our script
// in a new GroovyShell so that we don't affect subsequent examples.
// script:
x = 3
println "$_"
y = 'cat' * x
println "$_"

// metaUnderscore:
//void setProperty(String n, v) {
//    super.setProperty('_',v)
//    super.setProperty(n,v)
//}

new GroovyShell().evaluate(metaUnderscore + script)
// =>
// 3
// catcatcat

// We can get a little bit fancier by making an UnderscoreAware class
// that wraps up some of this functionality. This is not recommended
// as good Groovy style but mimicks the $_ behaviour in a sinple way.
class UnderscoreAware implements GroovyInterceptable {
    private _saved
    void setProperty(String n, v) {
        _saved = v
        this.metaClass.setProperty(this, n, v)
    }
    def getProperty(String n) {
        if (n == '_') return _saved
        this.metaClass.getProperty(this, n)
    }
    def invokeMethod(String name, Object args) {
        if (name.startsWith('print') && args.size() == 0)
            args = [_saved] as Object[]
        this.metaClass.invokeMethod(this, name, args)
    }
}

class PerlishClass extends UnderscoreAware {
    private _age
    def setAge(age){ _age = age }
    def getAge(){ _age }
    def test() {
        age = 25
        println "$_"   // explicit $_ supported
        age++
        println()      // implicit $_ will be injected
    }
}

def x = new PerlishClass()
x.test()
// =>
// 25
// 26

// Autoappending hash:
class AutoMap extends HashMap {
    void setProperty(String name, v) {
        if (containsKey(name)) {
            put(name, get(name) + v)
        } else {
            put(name, [v])
        }
    }
}
m = new AutoMap()
m.beer = 'guinness'
m.food = 'potatoes'
m.food = 'peas'
println m
// => ["food":["potatoes", "peas"], "beer":["guinness"]]

// Case-Insensitive Hash:
class FoldedMap extends HashMap {
    void setProperty(String name, v) {
        put(name.toLowerCase(), v)
    }
    def getProperty(String name) {
        get(name.toLowerCase())
    }
}
tab = new FoldedMap()
tab.VILLAIN = 'big '
tab.herOine = 'red riding hood'
tab.villain += 'bad wolf'
println tab
// => ["heroine":"red riding hood", "villain":"big bad wolf"]

// Hash That "Allows Look-Ups by Key or Value":
class RevMap extends HashMap {
    void setProperty(String n, v) { put(n,v); put(v,n) }
    def remove(n) { super.remove(get(n)); super.remove(n) }
}
rev = new RevMap()
rev.Rojo = 'Red'
rev.Azul = 'Blue'
rev.Verde = 'Green'
rev.EVIL = [ "No way!", "Way!!" ]
rev.remove('Red')
rev.remove('Azul')
println rev
// =>
// [["No way!", "Way!!"]:"EVIL", "EVIL":["No way!", "Way!!"], "Verde":"Green", "Green":"Verde"]

// Infinite loop scenario:
// def x(n) { x(++n) }; x(0)
// => Caught: java.lang.StackOverflowError

// Multiple Streams scenario:
class MultiStream2 extends PrintStream {
    def streams
    MultiStream2(List streams) {
        super(streams[0])
        this.streams = streams
    }
    void println(String x) {
        streams.each{ it.println(x) }
    }
}
tee = new MultiStream2([System.out, System.err])
tee.println ('This goes two places')
// =>
// This goes two places
// This goes two places
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.0
//----------------------------------------------------------------------------------
//As discussed in 14.1, many database options exist, one of which is JDBC.
//Over 200 JDBC drivers are listed at the following URL:
//http://developers.sun.com/product/jdbc/drivers/browse_all.jsp
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.1
//----------------------------------------------------------------------------------
// Groovy can make use of various Java persistence libraries and has special
// support built-in (e.g. datasets) for interacting wth RDBMS systems.
// Some of the options include:
//   object serialization (built in to Java)
//   pbeans: pbeans.sf.net
//   prevayler: http://www.prevayler.org
//   Berkeley DB Java edition: http://www.oracle.com/database/berkeley-db/je/
//   JDBC: Over 200 drivers are listed at http://developers.sun.com/product/jdbc/drivers
//   Datasets (special Groovy support)
//   XML via e.g. xstream or JAXB or XmlBeans or ...
//   ORM: over 20 are listed at http://java-source.net/open-source/persistence
//   JNI: can be used directly on a platform that supports e.g. DBM or via
//     a cross platform API such as Apache APR which includes DBM routines:
//     http://apr.apache.org/docs/apr-util/0.9/group__APR__Util__DBM.html
//   jmork: used for Firefox/Thunderbird databases, e.g. address books, history files
// JDBC or Datasets would normally be most common for all examples in this chapter.


// Example shown using berkeley db Java edition - not quite as transparent as
// cookbook example as Berkeley DB Java addition makes transactions visible.
import com.sleepycat.je.*
tx = null
envHome = new File("D:/Projects/GroovyExamples/Pleac/data/db")

myEnvConfig = new EnvironmentConfig()
myEnvConfig.setAllowCreate(true)
myEnv = new Environment(envHome, myEnvConfig)

myDbConfig = new DatabaseConfig()
myDbConfig.setAllowCreate(true)
myDb = myEnv.openDatabase(tx, "vendorDB", myDbConfig)

theKey = new DatabaseEntry("key".getBytes("UTF-8"))
theData = new DatabaseEntry("data".getBytes("UTF-8"))
myDb.put(tx, theKey, theData)
if (myDb.get(tx, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
    key = new String(theKey.data, "UTF-8")
    foundData = new String(theData.data, "UTF-8")
    println "For key: '$key' found data: '$foundData'."
}
myDb.delete(tx, theKey)
myDb.close()
myEnv.close()


// userstats using pbeans
//import net.sourceforge.pbeans.*
interface Persistent{}
class Store{}
// on *nix use: whotext = "who".execute().text
whotext = '''
gnat ttyp1 May 29 15:39 (coprolith.frii.com)
bill ttyp1 May 28 15:38 (hilary.com)
gnit ttyp1 May 27 15:37 (somewhere.org)
'''

class LoginInfo implements Persistent {
    LoginInfo() {}
    LoginInfo(name) { this.name = name; loginCount = 1 }
    String name
    int loginCount
}

def printAllUsers(store) {
    printUsers(store, store.select(LoginInfo.class).collect{it.name}.sort())
}

def printUsers(store, list) {
    list.each{
        println "$it  ${store.selectSingle(LoginInfo.class, 'name', it).loginCount}"
    }
}

def addUsers(store) {
    whotext.trim().split('\n').each{
        m = it =~ /^(\S+)/
        name = m[0][1]
        item = store.selectSingle(LoginInfo.class, 'name', name)
        if (item) {
            item.loginCount++
            store.save(item)
        } else {
            store.insert(new LoginInfo(name))
        }
    }
}

def ds = new jdbcDataSource()
ds.database = 'jdbc:hsqldb:hsql://localhost/mydb'
ds.user = 'sa'
ds.password = ''
store = new Store(ds)
if (args.size() == 0) {
    addUsers(store)
} else if (args == ['ALL']) {
    printAllUsers(store)
} else {
    printUsers(store, args)
}
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.2
//----------------------------------------------------------------------------------
// Groovy would normally use JDBC here (see 14.1 for details)
//import com.sleepycat.je.*
tx = null
envHome = new File("D:/Projects/GroovyExamples/Pleac/data/db")

myEnvConfig = new EnvironmentConfig()
myEnvConfig.setAllowCreate(true)
myEnv = new Environment(envHome, myEnvConfig)

myDbConfig = new DatabaseConfig()
myDbConfig.setAllowCreate(true)
myDb = myEnv.openDatabase(tx, "vendorDB", myDbConfig)

theKey = new DatabaseEntry("key".getBytes("UTF-8"))
theData = new DatabaseEntry("data".getBytes("UTF-8"))
myDb.put(tx, theKey, theData)
myDb.close()
// clear out database
returnCount = true
println myEnv.truncateDatabase(tx, "vendorDB", returnCount) + ' records deleted'
// remove database
myEnv.removeDatabase(tx, "vendorDB")
myEnv.close()
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.3
//----------------------------------------------------------------------------------
// Original cookbook example not likely in Groovy.
// Here is a more realistic example, copying pbeans -> jdbc
// Creation of pbeans database not strictly needed but shown for completion

//import net.sourceforge.pbeans.*
import groovy.sql.Sql

ds = new jdbcDataSource()
ds.database = 'jdbc:hsqldb:hsql://localhost/mydb'
ds.user = 'sa'
ds.password = ''
store = new Store(ds)

class PersonX implements Persistent {
    String name
    String does
    String email
}

// populate with test data
store.insert(new PersonX(name:'Tom Christiansen', does:'book author', email:'tchrist@perl.com'))
store.insert(new PersonX(name:'Tom Boutell', does:'Poet Programmer', email:'boutell@boutell.com'))

people = store.select(PersonX.class)

db = new Sql(ds)

db.execute 'CREATE TABLE people ( name VARCHAR, does VARCHAR, email VARCHAR );'
people.each{ p ->
    db.execute "INSERT INTO people ( name, does, email ) VALUES ($p.name,$p.does,$p.email);"
}
db.eachRow("SELECT * FROM people where does like 'book%'"){
    println "$it.name, $it.does, $it.email"
}
db.execute 'DROP TABLE people;'
// => Tom Christiansen, book author, tchrist@perl.com
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.4
//----------------------------------------------------------------------------------
// Groovy would normally use JDBC here (see 14.1 for details)
//import com.sleepycat.je.*

def copyEntries(indb, outdb) {
    cursor = indb1.openCursor(null, null)
    while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS)
        outdb.out(tx, foundKey, foundData)
    cursor.close()
}

tx = null
envHome = new File("D:/Projects/GroovyExamples/Pleac/data/db")

myEnvConfig = new EnvironmentConfig()
myEnvConfig.setAllowCreate(true)
myEnv = new Environment(envHome, myEnvConfig)

myDbConfig = new DatabaseConfig()
myDbConfig.setAllowCreate(true)
indb1 = myEnv.openDatabase(tx, "db1", myDbConfig)
indb2 = myEnv.openDatabase(tx, "db2", myDbConfig)
outdb = myEnv.openDatabase(tx, "db3", myDbConfig)
foundKey = new DatabaseEntry()
foundData = new DatabaseEntry()
copyEntries(indb1, outdb)
copyEntries(indb2, outdb)
cursor = indb2.openCursor(null, null)
while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS)
    outdb.out(tx, foundKey, foundData)
cursor.close()
indb1.close()
indb2.close()
outdb.close()
myEnv.close()
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.5
//----------------------------------------------------------------------------------
// If you are using a single file based persistence mechanism you can
// use the file locking mechanisms mentioned in 7.11 otherwise the
// database itself or the ORM layer will provide locking mechanisms.
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.6
//----------------------------------------------------------------------------------
// N/A for most Java/Groovy persistent technologies.
// Use indexes for RDBMS systems.
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.7
//----------------------------------------------------------------------------------
 // We can write a category that allows the ArrayList class
 // to be persisted as required.
 class ArrayListCategory {
     static file = new File('/temp.txt')
     static void save(ArrayList self) {
         def LS = System.getProperty('line.separator')
         file.withWriter{ w ->
             self.each{ w.write(it + LS)  }
         }
     }
 }

 lines = '''
 zero
 one
 two
 three
 four
 '''.trim().split('\n') as ArrayList

 use(ArrayListCategory) {
     println "ORIGINAL"
     for (i in 0..<lines.size())
         println "${i}: ${lines[i]}"

     a = lines[-1]
     lines[-1] = "last"
     println "The last line was [$a]"

     a = lines[0]
     lines = ["first"] + lines[1..-1]
     println "The first line was [$a]"

     lines.add(3, 'Newbie')
     lines.add(1, 'New One')

     lines.remove(3)

     println "REVERSE"
     (lines.size() - 1).downto(0){ i ->
         println "${i}: ${lines[i]}"
     }
     lines.save()
 }
 // =>
 // ORIGINAL
 // 0: zero
 // 1: one
 // 2: two
 // 3: three
 // 4: four
 // The last line was [four]
 // The first line was [zero]
 // REVERSE
 // 5: last
 // 4: three
 // 3: Newbie
 // 2: one
 // 1: New One
 // 0: first
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.8
//----------------------------------------------------------------------------------
// example using pbeans
//import net.sourceforge.pbeans.*
ds = new jdbcDataSource()
ds.database = 'jdbc:hsqldb:hsql://localhost/mydb'
ds.user = 'sa'
ds.password = ''
store = new Store(ds)

class PersonY implements Persistent {
    String name
    String does
    String email
}

name1 = 'Tom Christiansen'
name2 = 'Tom Boutell'

store.insert(new PersonY(name:name1, does:'book author', email:'tchrist@perl.com'))
store.insert(new PersonY(name:name2, does:'shareware author', email:'boutell@boutell.com'))

tom1 = store.selectSingle(PersonY.class, 'name', name1)
tom2 = store.selectSingle(PersonY.class, 'name', name2)

println "Two Toming: $tom1 $tom2"

if (tom1.name == tom2.name && tom1.does == tom2.does && tom1.email == tom2.email)
    println "You're having runtime fun with one Tom made two."
else
    println "No two Toms are ever alike"

tom2.does = 'Poet Programmer'
store.save(tom2)
// =>
// Two Toming: Person@12884e0 Person@8ab708
// No two Toms are ever alike
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.9
//----------------------------------------------------------------------------------
// Use one of the mechanisms mentioned in 14.1 to load variables at the start
// of the script and save them at the end. You can save the binding, individual
// variables, maps of variables or composite objects.
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.10
//----------------------------------------------------------------------------------
import groovy.sql.Sql

users = ['20':'Joe Bloggs', '40':'Bill Clinton', '60':'Ben Franklin']

def source = new jdbcDataSource()
source.database = 'jdbc:hsqldb:mem:PLEAC'
source.user = 'sa'
source.password = ''
db = new Sql(source)

db.execute 'CREATE TABLE users ( uid INT, login CHAR(8) );'
users.each{ uid, login ->
    db.execute "INSERT INTO users ( uid, login ) VALUES ($uid,$login);"
}
db.eachRow('SELECT uid, login FROM users WHERE uid < 50'){
    println "$it.uid $it.login"
}
db.execute 'DROP TABLE users;'
// =>
// 20 Joe Bloggs
// 40 Bill Clinton
//----------------------------------------------------------------------------------


// @@PLEAC@@_14.11
//----------------------------------------------------------------------------------
// variation to cookbook: uses Firefox instead of Netscape, always assumes
// argument is a regex, has some others args, retains no args to list all

// uses jmork mork dbm reading library:
//     http://www.smartwerkz.com/projects/jmork/index.html
//import mork.*
class MorkDocument{}
class CliBuilder{}
def cli = new CliBuilder()
cli.h(longOpt: 'help', 'print this message')
cli.e(longOpt: 'exclude', 'exclude hidden history entries (js, css, ads and images)')
cli.c(longOpt: 'clean', 'clean off url query string when reporting urls')
cli.v(longOpt: 'verbose', 'show referrer and first visit date')
def options = cli.parse(args)
if (options.h) { cli.usage(); System.exit(0) }
regex = options.arguments()
if (regex) regex = regex[0]
reader = new FileReader('Pleac/data/history.dat')
morkDocument = new MorkDocument(reader)
tables = morkDocument.tables
tables.each{ table ->
    table.rows.each { row ->
        url = row.getValue('URL')
        if (options.c) url = url.tokenize('?')[0]
        if (!regex || url =~ regex) {
            if (!options.e || row.getValue('Hidden') != '1') {
                println "$url\n    Last Visited: ${date(row,'LastVisitDate')}"
                if (options.v) {
                    println "    First Visited: ${date(row,'FirstVisitDate')}"
                    println "    Referrer: ${row.getValue('Referrer')}"
                }
            }
        }
    }
}
def date(row, key) {
    return new Date((long)(row.getValue(key).toLong()/1000))
}
// $ groovy gfh -ev oracle' =>
// http://www.oracle.com/technology/products/jdev/index.html
//     Last Visited: Thu Feb 15 20:20:36 EST 2007
//     First Visited: Thu Feb 15 20:20:36 EST 2007
//     Referrer: http://docs.codehaus.org/display/GROOVY/Oracle+JDeveloper+Plugin
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.1
//----------------------------------------------------------------------------------
// The are several Java options builder packages available. Some popular ones:
//   Apache Jakarta Commons CLI: http://jakarta.apache.org/commons/cli/
//   jopt-simple: http://jopt-simple.sourceforge.net
//   args4j: https://args4j.dev.java.net/ (requires Java 5 with annotations)
//   jargs: http://jargs.sourceforge.net/
//   te-code: http://te-code.sourceforge.net/article-20041121-cli.html
// Most of these can be used from Groovy with some Groovy code benefits.
// Groovy also has the CliBuilder built right in.


// CliBuilder example
cli = new CliBuilder()
cli.v(longOpt: 'verbose', 'verbose mode')
cli.D(longOpt: 'Debug', 'display debug info')
cli.o(longOpt: 'output', 'use/specify output file')
options = cli.parse(args)
if (options.v) // ...
if (options.D) println 'Debugging info available'
if (options.o) {
    println 'Output file flag was specified'
    println "Output file is ${options.o}"
}
// ...

// jopt-simple example 1 (short form)
cli = new joptsimple.OptionParser("vDo::")
options = cli.parse(args)
if (options.wasDetected('o')) {
    println 'Output file flag was specified.'
    println "Output file is ${options.argumentsOf('o')}"
}
// ...


// jopt-simple example 2 (declarative form)
op = new joptsimple.OptionParser()
VERBOSE = 'v';  op.accepts( VERBOSE,  "verbose mode" )
DEBUG   = 'D';  op.accepts( DEBUG,    "display debug info" )
OUTPUT  = 'o';  op.accepts( OUTPUT,   "use/specify output file" ).withOptionalArg().
    describedAs( "file" ).ofType( File.class )
options = op.parse(args)
params = options.nonOptionArguments()
if (options.wasDetected( DEBUG )) println 'Debugging info available'
// ...
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.2
//----------------------------------------------------------------------------------
// Groovy like Java can be run in a variety of scenarios, not just interactive vs
// non-interative, e.g. within a servlet container. Sometimes InputStreams and other
// mechanisms are used to hide away differences between the different containers
// in which code is run; other times, code needs to be written purpose-built for
// the container in which it is running. In most situations where the latter applies
// the container will have specific lifecycle mechanisms to allow the code to
// access specific needs, e.g. javax.servlet.ServletRequest.getInputStream()
// rather than System.in
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.3
//----------------------------------------------------------------------------------
// Idiomatically Groovy encourages GUI over text-based applications where a rich
// interface is desirable. Libraries for richer text-based interfaces include:
// jline: http://jline.sourceforge.net
// jcurses: http://sourceforge.net/projects/javacurses/
// java-readline: http://java-readline.sourceforge.net
// enigma console: http://sourceforge.net/projects/enigma-shell/
// Note: Run examples using these libraries from command line not inside an IDE.

// If you are using a terminal/console that understands ANSI codes
// (excludes WinNT derivatives) you can just print the ANSI codes
print ((char)27 + '[2J')

// jline has constants for ANSI codes
//import jline.ANSIBuffer
//print ANSIBuffer.ANSICodes.clrscr()
// Also available through ConsoleReader.clearScreen()
println new jline.console.ConsoleReader().clearScreen()

// Using jcurses
import jcurses.system.*
bg = CharColor.BLACK
fg = CharColor.WHITE
screenColors = new CharColor(bg, fg)
Toolkit.clearScreen(screenColors)
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.4
//----------------------------------------------------------------------------------
// Not idiomatic for Groovy to use text-based applications here.

// Using jcurses: http://sourceforge.net/projects/javacurses/
// use Toolkit.screenWidth and Toolkit.screenHeight

// 'barchart' example
import jcurses.system.Toolkit
numCols = Toolkit.screenWidth
rand = new Random()
if (numCols < 20) throw new RuntimeException("You must have at least 20 characters")
values = (1..5).collect { rand.nextInt(20) }  // generate rand values
max = values.max()
ratio = (numCols - 12)/max
values.each{ i ->
    printf('%8.1f %s\n', [i as double, "*" * ratio * i])
}

// gives, for example:
//   15.0 *******************************
//   10.0 *********************
//    5.0 **********
//   14.0 *****************************
//   18.0 **************************************
// Run from command line not inside an IDE which may give false width/height values.
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.5
//----------------------------------------------------------------------------------
// Idiomatically Groovy encourages GUI over text-based applications where a rich
// interface is desirable. See 15.3 for richer text-based interface libraries.
// Note: Run examples using these libraries from command line not inside an IDE.

// If you are using a terminal/console that understands ANSI codes
// (excludes WinNT derivatives) you can just print the ANSI codes
ESC = "${(char)27}"
redOnBlack = ESC + '[31;40m'
reset = ESC + '[0m'
println (redOnBlack + 'Danger, Will Robinson!' + reset)

// jline has constants for ANSI codes
//import jline.ANSIBuffer
class ANSIBuffer{}

redOnBlack = ANSIBuffer.ANSICodes.attrib(31) + ANSIBuffer.ANSICodes.attrib(40)
reset = ANSIBuffer.ANSICodes.attrib(0)
println redOnBlack + 'Danger, Will Robinson!' + reset

// Using JavaCurses
//import jcurses.system.*
//import jcurses.widgets.*
whiteOnBlack = new CharColor(CharColor.BLACK, CharColor.WHITE)
Toolkit.clearScreen(whiteOnBlack)
redOnBlack = new CharColor(CharColor.BLACK, CharColor.RED)
Toolkit.printString("Danger, Will Robinson!", 0, 0, redOnBlack)
Toolkit.printString("This is just normal text.", 0, 1, whiteOnBlack)
// Blink not supported by JavaCurses

// Using jline constants for Blink
blink = ANSIBuffer.ANSICodes.attrib(5)
reset = ANSIBuffer.ANSICodes.attrib(0)
println (blink + 'Do you hurt yet?' + reset)

// Using jline constants for Coral snake rhyme
def ansi(code) { ANSIBuffer.ANSICodes.attrib(code) }
redOnBlack = ansi(31) + ansi(40)
redOnYellow = ansi(31) + ansi(43)
greenOnCyanBlink = ansi(32) + ansi(46) + ansi(5)
reset = ansi(0)
println redOnBlack + "venom lack"
println redOnYellow + "kill that fellow"
println greenOnCyanBlink + "garish!" + reset
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.6
//----------------------------------------------------------------------------------
// Default Java libraries buffer System.in by default.

// Using JavaCurses:
//import jcurses.system.Toolkit

print 'Press a key: '
println "\nYou pressed the '${Toolkit.readCharacter().character}' key"

// Also works for special keys:
//import jcurses.system.InputChar

print "Press the 'End' key to finish: "
ch = Toolkit.readCharacter()
assert ch.isSpecialCode()
assert ch.code == InputChar.KEY_END

// See also jline Terminal#readCharacter() and Terminal#readVirtualKey()
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.7
//----------------------------------------------------------------------------------
print "${(char)7}"

// Using jline constant
print "${jline.ConsoleOperations.KEYBOARD_BELL}"
// Also available through ConsoleReader.beep()

// Using JavaCurses (Works only with terminals that support 'beeps')
//import jcurses.system.Toolkit
Toolkit.beep()
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.8
//----------------------------------------------------------------------------------
// I think you would need to resort to platform specific calls here,
// E.g. on *nix systems call 'stty' using execute().
// Some things can be set through the packages mentioned in 15.3, e.g.
// echo can be turned on and off, but others like setting the kill character
// didn't appear to be supported (presumably because it doesn't make
// sense for a cross-platform toolkit).
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.9
//----------------------------------------------------------------------------------
// Consider using Java's PushbackInputStream or PushbackReader
// Different functionality to original cookbook but can be used
// as an alternative for some scenarios.
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.10
//----------------------------------------------------------------------------------
// If using Java 6, use Console.readPassword()
// Otherwise use jline (use 0 instead of mask character '*' for no echo):
password = new jline.console.ConsoleReader().readLine(new Character('*'))
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.11
//----------------------------------------------------------------------------------
// In Groovy (like Java) normal input is buffered so you can normally make
// edits before hitting 'Enter'. For more control over editing (including completion
// and history etc.) use one of the packages mentioned in 15.3, e.g. jline.
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.12
//----------------------------------------------------------------------------------
// Use javacurses or jline (see 15.3) for low level screen management.
// Java/Groovy would normally use a GUI for such functionality.

// Here is a slight variation to cookbook example. This repeatedly calls
// the command feedin on the command line, e.g. "cmd /c dir" on windows
// or 'ps -aux' on Linux. Whenever a line changes, the old line is "faded
// out" using font colors from white through to black. Then the new line
// is faded in using the reverse process.
//import jcurses.system.*
class CharColor{}
color = new CharColor(CharColor.BLACK, CharColor.WHITE)
Toolkit.clearScreen(color)
maxcol = Toolkit.screenWidth
maxrow = Toolkit.screenHeight
colors = [CharColor.WHITE, CharColor.CYAN, CharColor.YELLOW, CharColor.GREEN,
          CharColor.RED, CharColor.BLUE, CharColor.MAGENTA, CharColor.BLACK]
done = false
refresh = false
waittime = 8000
oldlines = []
def fade(line, row, colorList) {
    for (i in 0..<colorList.size()) {
        Toolkit.printString(line, 0, row, new CharColor(CharColor.BLACK, colorList[i]))
        sleep 10
    }
}
while(!done) {
    if (waittime > 9999 || refresh) {
        proc = args[0].execute()
        lines = proc.text.split('\n')
        for (r in 0..<maxrow) {
            if (r >= lines.size() || r > oldlines.size() || lines[r] != oldlines[r]) {
                if (oldlines != [])
                    fade(r < oldlines.size() ? oldlines[r] : ' ' * maxcol, r, colors)
                fade(r < lines.size() ? lines[r] : ' ' * maxcol, r, colors.reverse())
            }
        }
        oldlines = lines
        refresh = false
        waittime = 0
    }
    waittime += 200
    sleep 200
}

// Keyboard handling would be similar to 15.6.
// Something like below but need to synchronize as we are in different threads.
Thread.start{
    while(!done) {
        ch = Toolkit.readCharacter()
        if (ch.isSpecialCode() || ch.character == 'q') done = true
        else refresh = true
    }
}
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.13
//----------------------------------------------------------------------------------
// These examples uses expectj, a pure Java Expect-like module.
// http://expectj.sourceforge.net/
defaultTimeout = -1 // infinite
expect = new expectj.ExpectJ("logfile.log", defaultTimeout)
command = expect.spawn("program to run")
command.expect('Password', 10)
// expectj doesn't support regular expressions, but see readUntil
// in recipe 18.6 for how to manually code this
command.expect('invalid')
command.send('Hello, world\r')
// kill spawned process
command.stop()

// expecting multiple choices
// expectj doesn't support multiple choices, but see readUntil
// in recipe 18.6 for how to manually code this
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.14
//----------------------------------------------------------------------------------
// Methods not shown for the edit menu items, they would be the same as for the
// file menu items.

def print() {}
def save() {}
frame = new SwingBuilder().frame(title:'Demo') {
    menuBar {
        menu(mnemonic:'F', 'File') {
            menuItem (actionPerformed:this.&print, 'Print')
            separator()
            menuItem (actionPerformed:this.&save, 'Save')
            menuItem (actionPerformed:{System.exit(0)}, 'Quit immediately')
        }
        menu(mnemonic:'O', 'Options') {
            checkBoxMenuItem ('Create Debugging Info', state:true)
        }
        menu(mnemonic:'D', 'Debug') {
            group = buttonGroup()
            radioButtonMenuItem ('Log Level 1', buttonGroup:group, selected:true)
            radioButtonMenuItem ('Log Level 2', buttonGroup:group)
            radioButtonMenuItem ('Log Level 3', buttonGroup:group)
        }
        menu(mnemonic:'F', 'Format') {
            menu('Font') {
                group = buttonGroup()
                radioButtonMenuItem ('Times Roman', buttonGroup:group, selected:true)
                radioButtonMenuItem ('Courier', buttonGroup:group)
            }
        }
        menu(mnemonic:'E', 'Edit') {
            menuItem (actionPerformed:{}, 'Copy')
            menuItem (actionPerformed:{}, 'Cut')
            menuItem (actionPerformed:{}, 'Paste')
            menuItem (actionPerformed:{}, 'Delete')
            separator()
            menu('Object ...') {
                menuItem (actionPerformed:{}, 'Circle')
                menuItem (actionPerformed:{}, 'Square')
                menuItem (actionPerformed:{}, 'Point')
            }
        }
    }
}
frame.pack()
frame.show()
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.15
//----------------------------------------------------------------------------------
// Registration Example
import groovy.swing.SwingBuilder
def cancel(event) {
    println 'Sorry you decided not to register.'
    dialog.dispose()
}
def register(event) {
    if (swing.name?.text) {
        println "Welcome to the fold $swing.name.text"
        dialog.dispose()
    } else println "You didn't give me your name!"
}
def dialog(event) {
    dialog = swing.createDialog(title:'Entry')
    def panel = swing.panel {
        vbox {
            hbox {
                label(text:'Name')
                textField(columns:20, id:'name')
            }
            hbox {
                button('Register', actionPerformed:this.&register)
                button('Cancel', actionPerformed:this.&cancel)
            }
        }
    }
    dialog.getContentPane().add(panel)
    dialog.pack()
    dialog.show()
}
swing = new SwingBuilder()
frame = swing.frame(title:'Registration Example') {
    panel {
        button(actionPerformed:this.&dialog, 'Click Here For Registration Form')
        glue()
        button(actionPerformed:{System.exit(0)}, 'Quit')
    }
}
frame.pack()
frame.show()


// Error Example, slight variation to original cookbook
import groovy.swing.SwingBuilder
import javax.swing.WindowConstants as WC
import javax.swing.JOptionPane
def calculate(event) {
    try {
        swing.result.text = evaluate(swing.expr.text)
    } catch (Exception ex) {
        JOptionPane.showMessageDialog(frame, ex.message)
    }
}
swing = new SwingBuilder()
frame = swing.frame(title:'Calculator Example',
    defaultCloseOperation:WC.EXIT_ON_CLOSE) {
    panel {
        vbox {
            hbox {
                label(text:'Expression')
                hstrut()
                textField(columns:12, id:'expr')
            }
            hbox {
                label(text:'Result')
                glue()
                label(id:'result')
            }
            hbox {
                button('Calculate', actionPerformed:this.&calculate)
                button('Quit', actionPerformed:{System.exit(0)})
            }
        }
    }
}
frame.pack()
frame.show()
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.16
//----------------------------------------------------------------------------------
// Resizing in Groovy follows Java rules, i.e. is dependent on the layout manager.
// You can set preferred, minimum and maximum sizes (may be ignored by some layout managers).
// You can setResizable(false) for some components.
// You can specify a weight value for some layout managers, e.g. GridBagLayout
// which control the degree of scaling which occurs during resizing.
// Some layout managers, e.g. GridLayout, automaticaly resize their contained widgets.
// You can capture resize events and do everything manually yourself.
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.17
//----------------------------------------------------------------------------------
// Removing DOS console on Windows:
// If you are using java.exe to start your Groovy script, use javaw.exe instead.
// If you are using groovy.exe to start your Groovy script, use groovyw.exe instead.
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.18
//----------------------------------------------------------------------------------
// additions to original cookbook:
// random starting position
// color changes after each bounce
//import jcurses.system.*
color = new CharColor(CharColor.BLACK, CharColor.WHITE)
Toolkit.clearScreen(color)
rand = new Random()
maxrow = Toolkit.screenWidth
maxcol = Toolkit.screenHeight
rowinc = 1
colinc = 1
row = rand.nextInt(maxrow)
col = rand.nextInt(maxcol)
chars = '*-/|\\_'
colors = [CharColor.RED, CharColor.BLUE, CharColor.YELLOW,
          CharColor.GREEN, CharColor.CYAN, CharColor.MAGENTA]
delay = 20
ch = null
def nextChar(){
    ch = chars[0]
    chars = chars[1..-1] + chars[0]
    color = new CharColor(CharColor.BLACK, colors[0])
    colors = colors[1..-1] + colors[0]
}
nextChar()
while(true) {
    Toolkit.printString(ch, row, col, color)
    sleep delay
    row = row + rowinc
    col = col + colinc
    if (row in [0, maxrow]) { nextChar(); rowinc = -rowinc }
    if (col in [0, maxcol]) { nextChar(); colinc = -colinc }
}
//----------------------------------------------------------------------------------


// @@PLEAC@@_15.19
//----------------------------------------------------------------------------------
// Variation to cookbook. Let's you reshuffle lines in a multi-line string
// by drag-n-drop.
import java.awt.*
import java.awt.datatransfer.*
import java.awt.dnd.*
import javax.swing.*
import javax.swing.ScrollPaneConstants as SPC

class DragDropList extends JList implements
        DragSourceListener, DropTargetListener, DragGestureListener {
    def dragSource
    DropTarget dropTarget
    def dropTargetCell
    int draggedIndex = -1
    def localDataFlavor = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType)
    def supportedFlavors = [localDataFlavor] as DataFlavor[]

    DragDropList(model) {
        super()
        setModel(model)
        setCellRenderer(new DragDropCellRenderer(this))
        dragSource = new DragSource()
        dragSource.createDefaultDragGestureRecognizer(this, DnDConstants.ACTION_MOVE, this)
        dropTarget = new DropTarget(this, this)
    }

    void dragGestureRecognized(DragGestureEvent dge) {
        int index = locationToIndex(dge.dragOrigin)
        if (index == -1 || index == model.size() - 1) return
        def trans = new CustomTransferable(model.getElementAt(index), this)
        draggedIndex = index
        dragSource.startDrag(dge, Cursor.defaultCursor, trans, this)
    }

    void dragDropEnd(DragSourceDropEvent dsde) {
        dropTargetCell = null
        draggedIndex = -1
        repaint()
    }

    void dragEnter(DragSourceDragEvent dsde) { }

    void dragExit(DragSourceEvent dse) { }

    void dragOver(DragSourceDragEvent dsde) { }

    void dropActionChanged(DragSourceDragEvent dsde) { }

    void dropActionChanged(DropTargetDragEvent dtde) { }

    void dragExit(DropTargetEvent dte) { }

    void dragEnter(DropTargetDragEvent dtde) {
        if (dtde.source != dropTarget) dtde.rejectDrag()
        else dtde.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE)
    }

    void dragOver(DropTargetDragEvent dtde) {
        if (dtde.source != dropTarget) dtde.rejectDrag()
        int index = locationToIndex(dtde.location)
        if (index == -1 || index == draggedIndex + 1) dropTargetCell = null
        else dropTargetCell = model.getElementAt(index)
        repaint()
    }

    void drop(DropTargetDropEvent dtde) {
        if (dtde.source != dropTarget) {
            dtde.rejectDrop()
            return
        }
        int index = locationToIndex(dtde.location)
        if (index == -1 || index == draggedIndex) {
            dtde.rejectDrop()
            return
        }
        dtde.acceptDrop(DnDConstants.ACTION_MOVE)
        def dragged = dtde.transferable.getTransferData(localDataFlavor)
        boolean sourceBeforeTarget = (draggedIndex < index)
        model.remove(draggedIndex)
        model.add((sourceBeforeTarget ? index - 1 : index), dragged)
        dtde.dropComplete(true)
    }
}

class CustomTransferable implements Transferable {
    def object
    def ddlist

    CustomTransferable(object, ddlist) {
        this.object = object
        this.ddlist = ddlist
    }

    Object getTransferData(DataFlavor df) {
        if (isDataFlavorSupported(df)) return object
    }

    boolean isDataFlavorSupported(DataFlavor df) {
        return df.equals(ddlist.localDataFlavor)
    }

    DataFlavor[] getTransferDataFlavors() {
        return ddlist.supportedFlavors
    }
}

class DragDropCellRenderer extends DefaultListCellRenderer {
    boolean isTargetCell
    def ddlist

    DragDropCellRenderer(ddlist) {
        super()
        this.ddlist = ddlist
    }

    Component getListCellRendererComponent(JList list, Object value,
            int index, boolean isSelected, boolean hasFocus) {
        isTargetCell = (value == ddlist.dropTargetCell)
        boolean showSelected = isSelected && !isTargetCell
        return super.getListCellRendererComponent(list, value, index, showSelected, hasFocus)
    }

    void paintComponent(Graphics g) {
        super.paintComponent(g)
        if (isTargetCell) {
            g.setColor(Color.black)
            g.drawLine(0, 0, size.width.intValue(), 0)
        }
    }
}

lines = '''
This is line 1
This is line 2
This is line 3
This is line 4
'''.trim().split('\n')
def listModel = new DefaultListModel()
lines.each{ listModel.addElement(it) }
listModel.addElement(' ') // dummy
def list = new DragDropList(listModel)
def sp = new JScrollPane(list, SPC.VERTICAL_SCROLLBAR_ALWAYS, SPC.HORIZONTAL_SCROLLBAR_NEVER)
def frame = new JFrame('Line Shuffle Example')
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE)
frame.contentPane.add(sp)
frame.pack()
frame.setVisible(true)
//----------------------------------------------------------------------------------
