mikehearn

/**
 * Maps elements of type F to E with change listeners working as expected.
 */
public class MappedList<E, F> extends TransformationList<E, F> {
    private final Function<F, E> mapper;
    private final ArrayList<E> mapped;

    /**
     * Creates a new MappedList list wrapped around the source list.
     * Each element will have the given function applied to it, such that the list is cast through the mapper.

mikehearn

/**
 * This list is created by dynamically concatenating all the source lists together.
 */
public class ConcatenatingList<T> extends ObservableListBase<T> implements ObservableList<T>  {
    private List<ObservableList<T>> sources = new ArrayList<>();
    private ListChangeListener<T> listener = this::sourceChanged;

    @SafeVarargs
    public ConcatenatingList(ObservableList<T>... source) {
        super();

mikehearn

// Contact: hearn@vinumeris.com

package lighthouse.threading;

import com.google.common.util.concurrent.Uninterruptibles;
import javafx.application.Platform;
import lighthouse.protocol.LHUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

mikehearn

    public static class AnimatedBindInfo {
        @Nullable public Timeline timeline;
        public NumberBinding bindFrom;
        public Runnable onAnimFinish;
    }

    public static AnimatedBindInfo animatedBind(Node node, WritableDoubleValue bindTo, NumberBinding bindFrom) {
        bindTo.set(bindFrom.doubleValue());   // Initialise.
        bindFrom.addListener((o, prev, cur) -> {
            AnimatedBindInfo info = (AnimatedBindInfo) node.getUserData();

mikehearn

class ThreadBox<T>(private val data: T) {
    synchronized fun use<R>(block: (T) -> R): R = block(data)
    synchronized fun useWith<R>(block: T.() -> R): R = data.block()
}

class UIThreadBox<T>(private val data: T) {
    fun use(block: (T) -> Unit): Unit = if (Platform.isFxApplicationThread()) block(data) else Platform.runLater { block(data) }
    fun useWith(block: T.() -> Unit): Unit = if (Platform.isFxApplicationThread()) data.block() else Platform.runLater { data.block() }

    /** Does a blocking get from the UI thread - danger of deadlock if not used properly! */

mikehearn

// This is a class that attempts to stop you accessing variables outside a lock.
//
// It does not do a perfect job, but can catch some common kinds of mistake, in
// particular when you accidentally try to work with objects inside closures that
// end up running later, outside the locked region (or in a different thread).

// EXAMPLE

val bank = ThreadBox(object {
    val accounts by arrayListOf(10, 0, 0, 0).guard()

mikehearn

open class LinearVal<T>(private val _v: T) {
    open operator fun invoke(): T {
        return _v
    }

    inline fun move(): LinearVal<T> {
        if (this !is UnavailableLinearVal)
            throw AssertionError()
        @Suppress("DEPRECATION")
        return __dupe()

mikehearn

interface SerializeableWithKryo

class ImmutableClassSerializer<T : SerializeableWithKryo>(val klass: KClass<T>) : Serializer<T>() {
    val props = klass.memberProperties.sortedBy { it.name }
    val propsByName = props.toMapBy { it.name }
    val constructor = klass.primaryConstructor!!

    init {
        // Verify that this class is immutable (all properties are final)
        assert(props.none { it is KMutableProperty<*> })

mikehearn

class A {
    fun shout() = println("go team A!")
}

class B {
    fun shout() = println("go team B!")
}

interface Shoutable {
    fun shout()

mikehearn

import java.io.File
import kotlin.system.measureTimeMillis

fun main(args: Array<String>) {
    val name = if (args.size > 1) args[0] else "/usr/share/dict/words"

    val time = measureTimeMillis {
        repeat(200) {
            go(name)
        }