debop

package org.scala.impatient

import org.junit.{Assert, Test}

/**
 * org.scala.impatient.CaseClassTest
 * User: sunghyouk.bae@gmail.com
 * Date: 13. 1. 4.
 */
class CaseClassTest {

debop

package kr.kth.commons.slf4j

import org.slf4j.{Logger => Slf4jLogger, Marker}
import annotation.varargs

/**
 * Scala를 위한 Logger 입니다.
 * User: sunghyouk.bae@gmail.com
 * Date: 13. 1. 6.
 */

debop

package kr.kth.commons.slf4j

import org.slf4j.Marker
import annotation.varargs

/**
 * 로그를 사용할 클래스에서 MixIn 방식으로 상속해서 사용하면 됩니다. ( class A extends Logger ... )
 * User: sunghyouk.bae@gmail.com
 * Date: 13. 1. 6.
 */

debop

  case class Currency(value: Double, unit: String = "USD")

  @Test
  def extractorMatch() {
    val amt = new Currency(29.95, "EUR")

    amt match {
      case Currency(amount, "USD") => log.debug(s" $$$amount")
      case Currency(amount, "EUR") => log.debug(s"€$amount")
      case _ => log.debug(amt)

debop

package kr.kth.commons.slf4j

import org.junit.Test

/**
 * User: sunghyouk.bae@gmail.com
 * Date: 13. 1. 8
 */
class LoggingTest extends Logging {

debop

package kr.kth.commons.slf4j

import org.slf4j.Marker
import annotation.varargs

/**
 * 로그를 사용할 클래스에서 MixIn 방식으로 상속해서 사용하면 됩니다. ( class A extends Logger ... )
 * User: sunghyouk.bae@gmail.com
 * Date: 13. 1. 6.
 */

debop

def runUnitAsParallel(count: Int)(block: => Unit) {
        log.debug("멀티스레드 환경에서 메소드들을 [{}] 번 실행합니다.", count)
        try {
            val latch = new CountDownLatch(count)
            val pc = collection.parallel.mutable.ParArray.iterate(0, count)(x => x)
            pc.tasksupport = new ThreadPoolTaskSupport()
            pc map {
                _ => {
                    block
                    latch.countDown()

debop

    private final val LowerBound: Int = 0
    private final val UpperBound: Int = 100000

    @Test
    def runUnitAsParallelTest {
        def runnable = {
            (LowerBound to UpperBound).foreach {
                i => Hero.findRoot(i)
            }
            log.debug("Unit: FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound))

debop

private static ExecutorService newExecutorService() {
        return Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    }

    public static void runTasks(int count, final Runnable runnable) {

        ExecutorService executor = newExecutorService();

        try {
            final CountDownLatch latch = new CountDownLatch(count);

debop

    public static <T, V> List<V> run(final Iterable<T> elements, final Function1<T, V> function) {
        shouldNotBeNull(elements, "elements");
        shouldNotBeNull(function, "function");

        ExecutorService executor = Executors.newFixedThreadPool(PROCESS_COUNT);
        final List<V> results = new ArrayList<V>();

        if (log.isDebugEnabled())
            log.debug("작업을 병렬로 수행합니다. 작업 스레드 수=[{}]", PROCESS_COUNT);