protected BlockingQueue<Combination> permuteWithFewerPositionsThanObjects(List<DataObject> remainingObjects,
                                                                            List<Position> remainingPositions,
                                                                            Combination currentCombination,
                                                                            BlockingQueue<Combination> runningList) throws InterruptedException {
        if (Thread.currentThread().isInterrupted()) {
            return null;
        } else if (remainingPositions.isEmpty()) {
            if (!currentCombination.isEmpty()) runningList.put(currentCombination);
        } else {
            List<Position> updatedRemainingPositions = new ArrayList<>(remainingPositions);
            Position remainingPosition = remainingPositions.get(0);
            updatedRemainingPositions.remove(remainingPosition);
            for (DataObject remainingObject : remainingObjects) {

                List<DataObject> updatedRemainingObjects = new ArrayList<>(remainingObjects);
                updatedRemainingObjects.remove(remainingObject);

                Combination updatedCombination = new Combination(currentCombination);
                updatedCombination.addMapping(remainingPosition, remainingObject);

                permuteWithFewerPositionsThanObjects(updatedRemainingObjects,
                        updatedRemainingPositions,
                        updatedCombination,
                        runningList);
            }
        }

        return runningList;
    }