com.github.k0zka.finder4j.backtrack.BacktrackServiceImpl.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of finder4j-backtrack Show documentation
The newest version!
package com.github.k0zka.finder4j.backtrack

import org.slf4j.LoggerFactory
import java.util.concurrent.ExecutionException
import java.util.concurrent.ForkJoinPool

/**
 *
 */
class BacktrackServiceImpl constructor(
		private val executorService: ForkJoinPool = ForkJoinPool(Runtime.getRuntime().availableProcessors())
) : BacktrackService {

	private inner class Worker> constructor(private val state: X,
																   private val terminationStrategy: TerminationStrategy,
																   private val listener: SolutionListener,
																   private val factory: StepFactory) :
			Runnable {

		override fun run() {
			logger.debug("starting backtrack from state {}", state)
			val tracker = LocalParallelTrack(executorService, factory, terminationStrategy, listener)
			Backtrack.backtrack(state, factory, terminationStrategy, listener,
								tracker)
			tracker.join()
		}
	}

	private inner class AnyWorker> constructor(private val state: X,
																	private val terminationStrategy: TerminationStrategy,
																	private val listener: SolutionListener,
																	private val factory: StepFactory,
																	private val check: (X) -> Boolean) :
			Runnable {

		override fun run() {
			logger.debug("starting backtrack from state {}", state)
			val tracker = LocalAnyParallelTrack(executorService, factory, terminationStrategy, listener, check)
			Backtrack.backtrack(state, factory, terminationStrategy, listener,
								tracker, check)
			tracker.join()
		}
	}


	override fun > backtrack(state: X,
													factory: StepFactory,
													terminationStrategy: TerminationStrategy,
													listener: SolutionListener) {
		doInThreadPool(Worker(
				state, terminationStrategy, listener, factory))
	}

	private fun doInThreadPool(
			worker: Runnable) {
		try {
			executorService.submit(worker).get()
		} catch (e: InterruptedException) {
			throw IllegalStateException(e)
		} catch (e: ExecutionException) {
			throw IllegalStateException(e)
		}
	}

	override fun > backtrack(state: X,
												  factory: StepFactory,
												  terminationStrategy: TerminationStrategy,
												  listener: SolutionListener,
												  check: (X) -> Boolean) {
		doInThreadPool(AnyWorker(state, terminationStrategy, listener, factory, check))
	}

	override fun stop() {
		executorService.shutdown()
	}

	companion object {
		private val logger = LoggerFactory
				.getLogger(BacktrackServiceImpl::class.java)
	}
}