package com.tk.scala
/**
 * There is nothing called 'static' in scala, This way we are creating singleton object
 */
object MainClass {
  /**
   * args is a method parameter of type Array[String].
   * That is to say, args is a string array.
   *
   * ':Unit' defines the return type of the main function
   *  Unit is like void but its more than that.
   */
  def main(args:Array[String]):Unit = {
    //declaration of String variable firstName
    var firstName: String = "Kuldeep";
    // similar declaration as above String. However, we don’t explicitly
    // specify any type.
    // This is because we’re taking advantage of Scala’s type inference mechanism
    var lastName = "Singh";
    // val represents the declaration of constant
    // Think of it like a shorter form of Java’s final modifier
    val greeting:String = "Hello"
    println(greeting + " " + firstName + " " + lastName)
  }
}

package com.tk.scala
object MainClass extends Application {
    //declaration of String variable firstName
    var firstName: String = "Kuldeep";    
    var lastName = "Singh";
    val greeting:String = "Hello"
    println(greeting + " " + firstName + " " + lastName)
  
}

package com.tk.scala;

import scala.Predef.;
import scala.collection.mutable.StringBuilder;
// Singleton class
public final class MainClass$
{
  public static final  MODULE$;
  static
  {
    new ();
  }
  public void main(String[] args)
  {
    String firstName = "Kuldeep";
    String lastName = "Singh";
    String greeting = "Hello";
    Predef..MODULE$.println(new StringBuilder().append(greeting).append(" ").append(firstName).append(" ").append(lastName).toString());
  }
   // private constructor of singleton class
  private MainClass$()
  {
    MODULE$ = this;
  }
}

package com.tk.scala
class Product {
  // declaration of private Int variable price
  private var _price: Int = 0
  // definition of getter method for price
  // method name price returning Int variable price
  def price = _price
  // above declaration is same as
  // def price:Int = {_price};
  // definition of setter method
  // here underscore is acting like a reserve keyword
  def price_=(value: Int): Unit = _price = value
}
/**
 * Main object
 */
object AppMainClass {
  def main(args: Array[String]) =
    {
      var product = new Product();
      // calling setter to set value
      product.price = 12;
      print("Price of product is: ")
      println(product.price)
    }
}

public class Product
{
  private int _price = 0;
  private int _price() { return this._price; } 
  private void _price_$eq(int x$1) { this._price = x$1; }
 public int price()
  {
    return _price();
  }
  public void price_$eq(int value)
  {
    _price_$eq(value);
  }
}
public final class AppMainFx$
{
  public static final  MODULE$;
  static
  {
    new ();
  }
  public void main(String[] args)
  {
    Product product = new Product();
    product.price_$eq(12);
    Predef..MODULE$.print("Price of product is: ");
    Predef..MODULE$.println(BoxesRunTime.boxToInteger(product.price()));
  }
  private AppMainFx$()
  {
    MODULE$ = this;
  }
}

package com.tk.scala
/**
 * Abstract Class declaration
 */
abstract class Person {
  // constant declaration of type string using keyword ‘val’
  val SPACE: String = " "
  /**
   * These are a public variable (Scala elements are public by default)
   * 
   * Scala supports encapsulation as well, but its syntax is considerably
   * less verbose than Java’s. Effectively, all public variables become instance 
   * properties.
   */
  var firstName: String = null
  var lastName: String = null
  // abstract method
  def getDetails(): Unit
}
/**
 * Concrete Employee class extending person class
 * 
 * Constructor: Employee class with parameterized constructor with two
 * parameters firstName and lastName inherited from Person class.
 * The constructor isn’t a special method syntactically like in java,
 * it is the body of the class itself.
 */
class Employee(firstName: String, lastName: String) extends Person {
  val profession:String = "Employee";
  // implementation of abstract methods
  def getDetails() = {
    println("Personal Details: " + firstName + SPACE + lastName)
  }
  /**
   * Override is actually a keyword.
   * It is a mandatory method modifier for any method with a signature which
   * conflicts with another method in a superclass.
   * Thus overriding in Scala isn’t implicit (as in Java, Ruby, C++, etc), but explicitly declared.
   */
  override def toString = "[" + profession +": firstName=" + firstName + " lastName=" + lastName + "]"
}

/**
 * Concrete Teacher class extending person class
 */
class Teacher(firstName: String, lastName: String) extends Person {
  val profession:String = "Teacher";
  def getDetails() = {
    println("Personal Details: " + firstName + SPACE + lastName)
  }
  override def toString = "[" + profession +": firstName=" + firstName + " lastName=" + lastName + "]"
}
object App {
  def main(args: Array[String]) =
    {
      var emp = new Employee("Kuldeep", "Singh");
      println(emp);
      var teacher = new Teacher("Kuldeep", "Thinker")
      println(teacher)
    }
}

package com.tk.scala
/**
 * Class demonstrating list
 */
class ScalaList {
  /**
   * Creation list of types string
   */
  val fruit1: List[String] = List("apples", "oranges", "pears")
  /**
   * All lists can be defined using two fundamental building blocks,
   * a tail Nil and :: which is pronounced cons. Nil also represents the empty list.
   */
  val fruit2 = "apples" :: ("oranges" :: ("pears" :: Nil))
  val empty = Nil
  /**
   * Operations supported on list
   * As scala list is LinkList, operations as related to general link list operations/
   *
   * Some operations
   */
  def Operations(): Unit = {
    println("Head of fruit : " + fruit1.head)
    println("Tail of fruit : " + fruit1.tail)
    println("Check if fruit is empty : " + fruit1.isEmpty)
    println("Check if nums is empty : " + fruit1.isEmpty)
    println("Check if nums is empty : " + empty.isEmpty)
    traverseList
  }
  def traverseList() = {
    val iterator = fruit1.iterator;
    while (iterator.hasNext) {
      print(iterator.next())
      print("->")
    }
    println
  }
}
/**
 * Class demonstrating sets
 */
class ScalaSet {
  // Empty set of integer type
  var emptySet: Set[Int] = Set()
  // Set of integer type
  var oddIntegerSet: Set[Int] = Set(1, 3, 5, 7)
  var evenIntegerSet: Set[Int] = Set(2, 4, 6, 8)
  def operations(): Unit = {
    println("Head of fruit : " + oddIntegerSet.head)
    println("Tail of fruit : " + oddIntegerSet.tail)
    println("Check if fruit is empty : " + oddIntegerSet.isEmpty)
    println("Check if nums is empty : " + oddIntegerSet.isEmpty)
    println("Check if nums is empty : " + emptySet.isEmpty)
    //Concatenating Sets
    var concatinatedList = oddIntegerSet ++ evenIntegerSet
    println("Concatinated List : " + concatinatedList)
  }
}
/**
 * Class demonstrating maps
 */
class ScalaMap {
  // Empty hash table whose keys are strings and values are integers:
  /**
   * Note: While defining empty map, the type annotation is necessary
   * as the system needs to assign a concrete type to variable.
   */
  var emptyMap: Map[Char, Int] = Map()
  val colors = Map("red" -> "#FF0000",
    "azure" -> "#F0FFFF",
    "peru" -> "#CD853F")
  def operations() = {
    println("Keys in colors : " + colors.keys)
    println("Values in colors : " + colors.values)
    println("Check if colors is empty : " + colors.isEmpty)
    println("Check if nums is empty : " + emptyMap.isEmpty)
    tranverseMap
  }
  def tranverseMap() {
    println("Printing key value pair for map:::")
   // using for each loop to traverse map
    colors.keys.foreach { i =>
      print("Key = " + i)
      println(" Value = " + colors(i))
    }
  }
}
/**
 * Class demonstrating tuples
 */
class scalaTuple {
  val t = new Tuple3(1, "hello", Console)
  //same tuple can be declared as
  val t1 = (1, "hello", Console)
  val intergerTuple = (4, 3, 2, 1)
  def operations() = {
    println("Print sum of elements in integer tuples")
    val sum = intergerTuple._1 + intergerTuple._2 + intergerTuple._3 + intergerTuple._4
    transverseTuple
  }
  def transverseTuple {
    println("Printing elements in tuples:::")
    intergerTuple.productIterator.foreach { i => println("Value = " + i) }
  }
}
object CollectionMain {
  def main(args: Array[String]) =
    {
      var scalaList = new ScalaList();
      println("Printing operations on list::::")
      scalaList.Operations;
      var scalaSet = new ScalaSet();
      println("");
      println("Printing operations on Set::::")
      scalaSet.operations;
      var scalaMap = new ScalaMap();
      println("");
      println("Printing operations on Map::::")
      scalaMap.operations;
      var scalaTuple = new scalaTuple();
      println("");
      println("Printing operations on Tuple::::")
      scalaTuple.operations;
    }
}	

package com.tk.scala

import java.io.IOException
import java.io.FileNotFoundException
import scala.io.Source
import scala.reflect.io.Path
import java.io.File
import java.io.PrintWriter
/**
 * Scala example to show read and write operations on file
 */
class FileOperations {
  
  /**
   * create and add content to file
   * 
   * This example depicts how we use java API in scala
   * We can use any java class/API in scala
   */
  def writeFile(filePath:String, content:String) = {
    // using java file object to create a file
    var file:File = new File(filePath);
    if (file.createNewFile()) {
      println("New file created")
    } else {
      println("File alredy exists")
    }
    // using java print writer object to add content in file
    var writer:PrintWriter = new PrintWriter(file);
    if (content != null)
    	writer.write(content)
    writer.close();
  }
  /**
   * reads the given file are return the content
   * of that file
   */
  def readFile(filePath: String): String = {
    // here is scala io class to readfrom file
    var lines: String = null;
    // there is no checked exception in scala
    try {
      lines = scala.io.Source.fromFile(filePath).mkString
      // catch block for exception handing
    } catch {
      case ex: FileNotFoundException => {
        println("Missing file exception")
      }
      case ex: IOException => {
        println("IO Exception")
      }
    } finally {
      println("Exiting finally...")
    }
    // returning content of the file
    lines
  }
}
/**
 * Main object
 */
object FileOperationMain extends Application  {
  val filePath = "e:\\test.txt"
  var fileOpts: FileOperations = new FileOperations;
  // calling api to create/write file
  fileOpts.writeFile(filePath, "File operation example for scala");
  // calling api to read file
  println(fileOpts.readFile(filePath));
}

package com.tk.scala
/**
 * defining a trait
 * Trait can have abstract method as well
 * as well as concrete method
 */
trait Swimming {
  def swim() = println("I can swim")
}
/**
 * fly trait
 */
trait Fly {
  def fly() = println("I can fly")
}
/**
 * abstract class bird
 */
abstract class Bird {
  //abstract method
  def defineMe: String
}
/**
 * class having bird as well as trait properties
 */
class Penguin extends Bird with Swimming {
  /**
   * Short hand syntax of function defination
   * Following line means function flyMessage is
   * returing string value <I am good..>
   */
  def defineMe = "I am a Penguin"
  /**
   * This piece of code is equivalent to above definition of function
   */
  /*def defineMe() = {
    var str:String = "I am a Penguin"
    // returning string value (No return keyword required)
    str
  }*/
}
/**
 * class having all the traits
 */
class Pigeon extends Bird with Swimming with Fly {
  /**
   * defining defineMe function
   */
  def defineMe = "I am a Pigeon"
}
/**
 * AppMain class with main function
 */
object AppMain extends Application {
  // penguin instance have on swim trait
  var penguin = new Penguin
  println(penguin.defineMe)
  penguin.swim
  // pigeon instance have all traits
  var pigeon = new Pigeon
  println(pigeon.defineMe)
  pigeon.fly
  pigeon.swim
}

package com.tk.java;
import com.tk.scala.ScalaLearner;
/**
 * The Class JavaLearner.
 */
public class JavaLearner {
	private String firstName;
	private String lastName;
	public JavaLearner(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}
	public void consoleAppender() {
		System.out.println(firstName + " " + lastName + " is a java learner");
	}
	public static void main(String[] args) {
		JavaLearner printJava = new JavaLearner("Kuldeep", "Singh");
		printJava.consoleAppender();
		// create instance of scala class
		ScalaLearner printScala = new ScalaLearner("Dhruv", "Bansal");
		printScala.consoleAppender();
	}
}

package com.tk.scala
class ScalaLearner(firstName: String, lastName: String) {
  /**
   * Scala API prints message on console
   */
  def consoleAppender() = println(firstName + " " + lastName + "i am in scala learner")
}

/**
 * This Object is java representation of singleton object
 * this piece of code will generate class file with name
 * AppMain having singleton class AppMain having public
 * static void main method
 */
object AppMain {
  def main(args: Array[String]): Unit = {
    var scalaLearner = new ScalaLearner("Kuldeep", "Singh");
    scalaLearner.consoleAppender;

    // import class in the scope of another class only
    import com.nagarro.jsag.java.JavaLearner
    // creating instance of java class file
    var javaLearner = new JavaLearner("Dhruv", "Bansal");
    javaLearner.consoleAppender;
  }
}

package com.tk.scala;
/**
 * The Class SortAlgo.
 */
public class SortAlgo {
	/**
	 * Implementation of bubble sort algorithm.
	 * 
	 * @param inputArray
	 *            the input array
	 */
	public void bubbleSort(int inputArray[]) {
		int i, j, t = 0;
		int arryLength = inputArray.length;
		for (i = 0; i < arryLength; i++) {
			for (j = 1; j < (arryLength - i); j++) {
				if (inputArray[j - 1] > inputArray[j]) {
					t = inputArray[j - 1];
					inputArray[j - 1] = inputArray[j];
					inputArray[j] = t;
				}
			}
		}
	}
}

package com.tk.scala;
/**
 * The Class AppMain.
 */
public class AppMain {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		consoleAppender("Sort algo start time: " + start);
		Integer arraySize = 10000;
		consoleAppender("Population array...");
		int[] array = new int[arraySize];
		for (int i = 0; i < arraySize; i++) {
			array[i] = arraySize - i;
		}
		consoleAppender("Sorting array...");
		SortAlgo sortAlgo = new SortAlgo();
		sortAlgo.bubbleSort(array);
		long end = System.currentTimeMillis();
		consoleAppender("Sort algo end time: " + end);
		consoleAppender("Total time taken: " + (end - start));
	}
	private static void consoleAppender(String strValue) {
		System.out.println(strValue);
	}
}

package com.tk.scala
class SortAlgo {
  // implementation of bubble sort
  def bubbleSort(a: Array[Int]): Unit = {
    var i:Int = 1;
    for (i <- 0 to (a.length - 1)) {
      for (j <- (i - 1) to 0 by -1) {
        if (a(j) > a(j + 1)) {
          val temp = a(j + 1)
          a(j + 1) = a(j)
          a(j) = temp
        }
      }
    }
  }
}
package com.tk.scala
/**
 * Bubble sort singleton class with main method
 */
object BubbleSort {
  
  def main(args : Array[String]) : Unit = {
   // declaring and initiating local variable for performance measure
   var startTime:Long =  java.lang.System.currentTimeMillis();
   println("Sorting start time: " + startTime)
   val arraySize = 10000;
   // declaring Integer array
   var arry : Array[Int] =  new Array[Int](arraySize)
   println("Populating array...")
   for(i<- 0 to (arraySize - 1)){
     arry(i) = arraySize - i;
   }
   println("Sorting array...")
   var algo:SortAlgo = new SortAlgo;
   // calling sort API
   algo.bubbleSort(arry)
   var endTime:Long =  java.lang.System.currentTimeMillis();
   println("Sorting end time: " + endTime)
   println("Total time taken:" + (endTime - startTime))
  }
}