main/java/kernel/models/Kernel.java

package kernel.models;

import kernel.controllers.TDKLambdaPowerSupplyFactory;
import kernel.controllers.TaskRunner;
import kernel.controllers.variables.VariableProviderContainer;
import kernel.modbus.ModBusConnectionManager;
import kernel.modbus.ModbusConnector;
import kernel.serial_ports.PortDriver;
import kernel.serial_ports.SerialPort;
import kernel.views.CommPortReporter;
import kernel.views.DeviceContainer;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

public final class Kernel implements kernel.Kernel, CommPortReporter {

    private static final Logger log = LoggerFactory.getLogger(Kernel.class);

    private PortDriver portDriver;

    private kernel.models.DeviceContainer deviceRegistry;

    private kernel.models.VariableProviderContainer variableProviders;

    private kernel.controllers.TDKLambdaPowerSupplyFactory
            tdkLambdaPowerSupplyFactory;

    private kernel.controllers.PVCiPressureGaugeFactory
            pvCiPressureGaugeFactory;

    private TaskRunner runner = new kernel.models.TaskRunner();

    public Kernel(PortDriver portDriver){
        this.portDriver = portDriver;
        this.deviceRegistry = new kernel.models.DeviceContainer();
        createTDKLambdaPowerSupplyFactory();

        log.info("Started kernel {}", this.toString());

        createPVCIPressureGaugeFactory();
        createVariableProviderRegistry();
    }

    @Contract(pure = true)
    @Override public CommPortReporter getCommPortReporter(){
        return this;
    }

    @Override public List<String> getSerialPortNames(){
        List<String> portNames = this.portDriver.getSerialPortNames();
        handleLogging(portNames);
        return portNames;
    }

    @NotNull
    @Override public Boolean isPortInUse(String portName){
        SerialPort port = portDriver.getPortByName(portName);
        return port.isPortOpen();
    }

    @Override
    public PortDriver getPortDriver(){
        return this.portDriver;
    }

    @Contract(pure = true)
    @Override
    public kernel.controllers.DeviceRegistry getDeviceRegistryController(){
        return this.deviceRegistry;
    }

    @Contract(pure = true)
    @Override
    public DeviceContainer getDeviceRegistryView(){
        return this.deviceRegistry;
    }

    @Override
    public TDKLambdaPowerSupplyFactory getPowerSupplyFactory(){
        return this.tdkLambdaPowerSupplyFactory;
    }

    @Contract(" -> !null")
    @Override
    public ModbusConnector getModbusConnector(){
        return new ModBusConnectionManager();
    }

    @Override
    public kernel.controllers.PVCiPressureGaugeFactory
    getPressureGaugeFactory(){
        return this.pvCiPressureGaugeFactory;
    }

    @Contract(pure = true)
    @Override
    public kernel.views.VariableProviderContainer getVariableProvidersView(){
        return this.variableProviders;
    }

    @Contract(pure = true)
    @Override
    public VariableProviderContainer
            getVariableProvidersController(){
        return this.variableProviders;
    }

    @Override
    public TaskRunner getTaskRunner(){
        return this.runner;
    }

    @Override
    public void setTaskRunner(TaskRunner runner){
        this.runner = runner;
    }

    private void createTDKLambdaPowerSupplyFactory(){
        this.tdkLambdaPowerSupplyFactory = new kernel.models
                .TDKLambdaPowerSupplyFactory();
        this.tdkLambdaPowerSupplyFactory.setKernel(this);
    }

    private void createPVCIPressureGaugeFactory(){
        this.pvCiPressureGaugeFactory = new PVCiPressureGaugeFactory();
        this.pvCiPressureGaugeFactory.setKernel(this);
    }

    private void createVariableProviderRegistry(){
        this.variableProviders = new kernel.models.VariableProviderContainer();
    }

    private void handleLogging(List<String> portNames){
        if (portNames.isEmpty()) {
            writeLogEntryForEmptyList();
        } else {
            writeLogEntryForPortsDetected(portNames);
        }
    }

    private void writeLogEntryForEmptyList(){
        log.warn("Kernel {} has not detected any available serial ports",
                this.toString());
    }

    private void writeLogEntryForPortsDetected(List<String> portNames){
        for (String portName: portNames){
            log.info("Kernel {} detected serial port {}", this, portName);
        }
    }
}