package com.tk.groovy.poc
class GroovyHelloWorld {
	// declaring the string variable
	/** The first name. */
	String firstName
	String lastName
	/**
	 * Main.
	 *
	 * @param args the args
	 * This is how mail function is defined in groovy
	 */
	static void main(def args) {
		GroovyHelloWorld p = new GroovyHelloWorld()
		p.firstName("Kuldeep")
		p.lastName = "Singh"
		println("Hello " + p.firstName + " " + p.lastName);	}
}

package com.tk.groovy.poc;
class Person {
	String firstName;
	String lastName;
	
	static main(def args) {
		// creating instance of person class
		Person person = new Person();
		// groovy auto generates the setter and getter method of variables
		person.setFirstName("Kuldeep");
		person.setLastName("Singh")
		// calling autogenerated getter method
		println(person.getFirstName() + " " + person.getLastName())
	}
}

package com.tk.groovy.poc

class GroovyPerson {
	String firstName
	String lastName
	static void main(def args) {
		GroovyHelloWorld p = new GroovyHelloWorld()
		//Groovy default constructor
		GroovyPerson defaultPerson = new GroovyPerson();
		
		// 1 generated Constructor
		// similar constructor is generated for lastName also
		GroovyPerson personWithFirstNameOnly = new GroovyPerson(firstName :"Kuldeep")
		println(personWithFirstNameOnly.getFirstName());
		
		// 2 generated Constructor
		GroovyPerson person = new GroovyPerson(firstName :"Kuldeep", lastName :"Singh")
		println(person.firstName + " " +  person.lastName)
	}
}

package com.tk.groovy.poc
class GroovyClosures {
	/**
	 * Main Function.
	 *
	 * @param args the args
	 */
	def static main(args) {
		/**
		 * Defining closure printSum
		 *
		 * -> : is a special keyword here
		 */
		def printSum = { a, b -> println a+b }
		printSum(5,7)
		/**
		 * Closure with implicit argument
		 */
		def implicitArgClosure = { println it }
		implicitArgClosure( "I am using implicity variable 'it'" )
	}
}

package com.tk.groovy.poc
class GroovyCollections {
	def listOperations(){
		println("Operation over LIST: ")
		// defining the Integer type list using generic
		List list = [1, 2, 3, 4]
		// Note this is same as below declaration
		// Here we are explicitly declaring the type of list
		//List<Integer> list = [1, 2, 3, 4]
		println("Iterating the list using variable assignment: ")
		// using .each method to iterate over list
		// 'itemVar' is implicitly declared as a variable of same type as list
		// with each block, values will be assigned to 'itemVar'
		// this is syntax of groovy Closure
		list.each{itemVar-> print itemVar + ", " }
		println("")
		println("Iterating the list using implicit variable 'it': ")
		// inspite of declaring the variable explicitly directly use
		// the implicit variable 'it'
		list.each{print it + ", "}
	}
	def mapOpertion(){
		println("Operation over MAP: ")
		def map = ["Java":"server", "Groovy":"server", "JavaScript":"web"]
		println("Iterating the map using variable assignment: ")
		map.each{k,v->
			print k + ", "
			println v
		}
		println("")
		println("Iterating the map using implicit variable 'it': ")
		map.each{
			print it.key + ", "
			println it.value
		}
	}
	def setOperations(){
		Set s1 = ["a", 2, "a", 2, 3]
		println("Iterating the map using variable assignment: ")
		s1.each{setVar-> print setVar + ", "}
		println("")
		println("Iterating the set using implicit variable 'it': ")
		s1.each{ print it + ", "}
	}
	def rangeOperations() {
		def range = 1..50
		//get the end points of the range
		println()
		println ("Range starts from: " + range.from + " -- Range ends to: " + range.to)
		println("Iterating the range using variable assignment: ")
		range.each{rangeVar-> print rangeVar + ", "}
		println("")
		println("Iterating the range using implicit variable 'it': ")
		range.each{ print it + ", "}
	}
	/**
	 * Main Method
	 *
	 * @param args the args
	 * 
	 * This is how we declare a static method in groovy
	 * by using static keyword
	 */
	static main(def args){
		GroovyCollections groovyCol = new GroovyCollections()
		groovyCol.listOperations();
		println("")
		groovyCol.mapOpertion();
		println("")
		groovyCol.setOperations();
		println("")
		groovyCol.rangeOperations();
	}
}

package com.tk.groovy.poc
class GroovyFileOperations {
	private def writeFile(def String filePath, def String content) {
		try {
			def file = new File(filePath);
			// declaring out variable using groovy closer
			// writing content using groovy implicit out variable
			file.withWriter { out ->
				out.writeLine(content)
			}
			// all keyword defines all exceptions
		} catch (All) {
		// print the stack trace
			println(All)
		}
	}
	private def readFile(def String filePath) {
		def file = new File(filePath);
		file.eachLine { line -> println(line) }
	}
	def static main(def args) {
		def filePath = LICENCE.txt;
		def content = "testContent"
		GroovyFileOperations fileOp = new GroovyFileOperations();
		println("Writing content in the file")
		fileOp.writeFile(filePath, content);
		println("Content from the file")
		fileOp.readFile(filePath);
	}
}

package com.tk.groovy.poc
class Dog {
	/**
	 * Bark.
	 */
	def bark() {
		println "woof!"
	}
	/**
	 * Sit.
	 */
	def sit() {
		println "sitting"
	}
	/**
	 * Jump.
	 */
	def jump() {
		println "boing!"
	}
	/**
	 * Do action.
	 *
	 * @param animal the animal
	 * @param action the action
	 * 
	 * This is how we define the static method
	 */
	def static doAction( animal, action ) {
		//action name is passed at invocation
		animal."$action"()
	}
	/**
	 * Main.
	 *
	 * @param args the args
	 */
	static main(def args) {
		def dog = new Dog()
		// calling the method by its name
		doAction( dog, "bark" )
		doAction( dog, "jump" )
	}
}

package com.tk.groovy.poc.groovy
import com.tk.groovy.poc.java.JavaLearner
/**
 * The Class GroovyPerson.
 */
class GroovyLearner {
	def printGroovy() {
		println("I am a groovy Learner")
	}
	static void main(def args) {
		JavaLearner javaLearner = new JavaLearner();
		javaLearner.printJava();
	}
}

package com.tk.groovy.poc.java;
import groovy.lang.GroovyClassLoader;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import org.codehaus.groovy.control.CompilationFailedException;
import com.nagarro.groovy.poc.groovy.GroovyLearner;

/**
 * The Class JavaLearner.
 */
public class JavaLearner {
	/**
	 * Prints the java.
	 */
	public void printJava() {
		System.out.println("I am a java learner");
	}
	/**
	 * The main method.
	 * 
	 * @param args
	 *            the arguments
	 */
	public static void main(String[] args) {
		// using GroovyCloassLoader class
		String relativeGroovyClassPath = "src\\com\\tk\\groovy\\poc\\groovy\\GroovyLearner.groovy";
		try {
			Class groovyClass = new GroovyClassLoader().parseClass(new File(relativeGroovyClassPath));
			Object groovyClassInstance = groovyClass.newInstance();
			groovyClass.getDeclaredMethod("printGroovy", new Class[] {}).invoke(groovyClassInstance, new Object[] {});
		} catch (CompilationFailedException | IOException | InstantiationException | IllegalAccessException
				| IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
			e.printStackTrace();
		}
		// directly calling groovy class in java
		// this work on the fact that both groovy and java are compiled to
		// .class file
		GroovyLearner groovyLearner = new GroovyLearner();
		groovyLearner.printGroovy();
	}
}

package com.tk.groovy.project

/**
 * The Class Build.
 */
class Build {
	def base_dir = "."
	def src_dir = base_dir + "/src"
	def lib_dir = base_dir + "/lib"
	def build_dir = base_dir + "/classes"
	def dist_dir = base_dir + "/dist"
	def file_name = "Fibonacci"
	def  ant=null;
	void clean() {
		ant.delete(dir: "${build_dir}")
		ant.delete(dir: "${dist_dir}")
	}

	/**
	 * Builds the.
	 */
	void build() {
		ant= new AntBuilder().sequential {
			taskdef name: "groovyc", classname: "org.codehaus.groovy.ant.Groovyc"
			groovyc srcdir: "src", destdir: "${build_dir}", {
				classpath {
					fileset dir: "${lib_dir}", { include name: "*.jar" }
					pathelement path: "${build_dir}"
				}
				javac source: "1.7", target: "1.7", debug: "on"
			}
			jar destfile: "${dist_dir}/${file_name}.jar", basedir: "${build_dir}",filesetmanifest: "mergewithoutmain",{
				manifest{
					attribute( name: 'Main-Class', value: "com.tk.groovy.Fibonacci" )
				}
			}
			java classname:"${file_name}", fork:'true',{
				classpath {
					fileset dir: "${lib_dir}", { include name: "*.jar" }
					pathelement path: "${build_dir}"
				}
			}
		}
	}
	/**
	 * Run.
	 *
	 * @param args the args
	 */
	void run(args) {
		if ( args.size() > 0 ) {
			invokeMethod(args[0], null )
		}
		else {
			build()
		}
	}
	/**
	 * Main.
	 *
	 * @param args the args
	 */
	static main(args) {
		def b = new Build()
		b.run(args)
	}
}

<?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>GroovyMavenPOC</groupId>
    <artifactId>GroovyMavenPOC</artifactId>
    <name>Example Project</name>
    <version>1.0.0</version>
    <dependencies>
        <dependency>
            <groupId>org.codehaus.groovy.maven.runtime</groupId>
            <artifactId>gmaven-runtime-1.6</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.groovy.maven</groupId>
                <artifactId>gmaven-plugin</artifactId>
                <version>1.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>generateStubs</goal>
                            <goal>compile</goal>
                            <goal>generateTestStubs</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

package com.tk.groovy.poc
import groovy.util.GroovyTestCase
class HelloWorldTest
    extends GroovyTestCase
{
    void testShow() {
        new HelloWorld().show()
    }
}	
package com.tk.groovy.poc
import groovy.util.GroovyTestCase
/**
 * The Class HelperTest.
 */
class HelperTest
    extends GroovyTestCase
{
    void testHelp() {
        new Helper().help(new HelloWorld())
    }
}

package com.nagarro.groovy.poc;
public class JavaFibonacci {
	public static int fibStaticTernary(int n) {
		return (n >= 2) ? fibStaticTernary(n - 1) + fibStaticTernary(n - 2) : 1;
	}
	public static int fibStaticIf(int n) {
		if (n >= 2)
			return fibStaticIf(n - 1) + fibStaticIf(n - 2);
		else
			return 1;
	}
	int fibTernary(int n) {
		return (n >= 2) ? fibStaticTernary(n - 1) + fibStaticTernary(n - 2) : 1;
	}
	int fibIf(int n) {
		if (n >= 2)
			return fibIf(n - 1) + fibIf(n - 2);
		else
			return 1;
	}
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		JavaFibonacci.fibStaticTernary(40);
		System.out.println("Java(static ternary): " + (System.currentTimeMillis() - start) + "ms");
		start = System.currentTimeMillis();
		JavaFibonacci.fibStaticIf(40);
		System.out.println("Java(static if): " + (System.currentTimeMillis() - start) + "ms");
		start = System.currentTimeMillis();
		new JavaFibonacci().fibTernary(40);
		System.out.println("Java(instance ternary): " + (System.currentTimeMillis() - start) + "ms");
		start = System.currentTimeMillis();
		new JavaFibonacci().fibIf(40);
		System.out.println("Java(instance if): " + (System.currentTimeMillis() - start) + "ms");
	}
}

package com.tk.groovy.poc
class GroovyFibonacci {
	static int fibStaticTernary (int n) {
		n >= 2 ? fibStaticTernary(n-1) + fibStaticTernary(n-2) : 1
	}
	static int fibStaticIf (int n) {
		if(n >= 2) fibStaticIf(n-1) + fibStaticIf(n-2) else 1
	}
	int fibTernary (int n) {
		n >= 2 ? fibTernary(n-1) + fibTernary(n-2) : 1
	}
	int fibIf (int n) {
		if(n >= 2) fibIf(n-1) + fibIf(n-2) else 1
	}
	public static void main(String[] args) {
		def warmup = true
		def warmUpIters = 50
		def start = System.currentTimeMillis()
		JavaFibonacci.fibStaticTernary(40)
		println("Groovy(static ternary): ${System.currentTimeMillis() - start}ms")
		start = System.currentTimeMillis()
		JavaFibonacci.fibStaticIf(40)
		println("Groovy(static if): ${System.currentTimeMillis() - start}ms")
		def fib = new JavaFibonacci()
		start = System.currentTimeMillis()
		fib.fibTernary(40)
		println("Groovy(instance ternary): ${System.currentTimeMillis() - start}ms")
		start = System.currentTimeMillis()
		fib.fibIf(40)
		println("Groovy(instance if): ${System.currentTimeMillis() - start}ms")
	}
}

package com.tk.groovy.poc;
public class ReadFileJava {
	private static String FILE_NAME=LICENCE.txt; 
	public static void readFile() {
		BufferedReader br = null;
		try {
			File file=new File(FILE_NAME);
			double bytes = file.length();
			double kilobytes = (bytes / 1024);
			double megabytes = (kilobytes / 1024);
			br = new BufferedReader(new FileReader(file));
			int count = 0;
			while (br.readLine() != null) {
				count++;
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		readFile();
		long end = System.currentTimeMillis();
		System.out.println("Time Consumed------>>>>" + (end - start)+"ms");
	}
}

package com.tk.groovy.poc
class GroovyReadFile {
	static main(def a){
		def filePath = "D:\\test.txt"
		long start = System.currentTimeMillis();
		int count = 0;
		new File(filePath).eachLine{ 
			count++;
		}
		println count;
		long end = System.currentTimeMillis();
		println ("Time Consumed------>>>>"+(end - start) +"ms");
	}
}