private boolean doAccept()

in common/src/main/java/org/mvndaemon/mvnd/common/logging/TerminalOutput.java [208:426]


    private boolean doAccept(Message entry) {
        switch (entry.getType()) {
            case Message.BUILD_STARTED: {
                BuildStarted bs = (BuildStarted) entry;
                this.name = bs.getProjectId();
                this.totalProjects = bs.getProjectCount();
                final int totalProjectsDigits = (int) (Math.log10(totalProjects) + 1);
                this.projectsDoneFomat = "%" + totalProjectsDigits + "d";
                this.maxThreads = bs.getMaxThreads();
                this.inputHandler.setMaxThreads(maxThreads);
                this.artifactIdFormat = "%-" + bs.getArtifactIdDisplayLength() + "s ";
                final int maxThreadsDigits = (int) (Math.log10(maxThreads) + 1);
                this.threadsFormat = "%" + (maxThreadsDigits * 3 + 2) + "s";
                if (maxThreads <= 1 || totalProjects <= 1) {
                    this.noBuffering = true;
                    display.update(Collections.emptyList(), 0);
                    applyNoBuffering();
                }
                break;
            }
            case Message.CANCEL_BUILD: {
                projects.values().stream().flatMap(p -> p.log.stream()).forEach(log);
                clearDisplay();
                try {
                    log.close();
                } catch (IOException e1) {
                    throw new RuntimeException(e1);
                }
                final AttributedStyle s = new AttributedStyle().bold().foreground(AttributedStyle.RED);
                new AttributedString("The build was canceled", s).println(terminal);
                terminal.flush();
                return false;
            }
            case Message.BUILD_EXCEPTION: {
                final BuildException e = (BuildException) entry;
                final String msg;
                if ("org.apache.commons.cli.UnrecognizedOptionException".equals(e.getClassName())) {
                    msg = "Unable to parse command line options: " + e.getMessage();
                } else {
                    msg = e.getClassName() + ": " + e.getMessage();
                }
                projects.values().stream().flatMap(p -> p.log.stream()).forEach(log);
                clearDisplay();
                try {
                    log.close();
                } catch (IOException e1) {
                    throw new RuntimeException(e1);
                }
                final AttributedStyle s = new AttributedStyle().bold().foreground(AttributedStyle.RED);
                new AttributedString(msg, s).println(terminal);
                terminal.flush();
                return false;
            }
            case Message.PROJECT_STARTED: {
                StringMessage be = (StringMessage) entry;
                final String artifactId = be.getMessage();
                projects.put(artifactId, new Project(artifactId));
                break;
            }
            case Message.MOJO_STARTED: {
                final MojoStartedEvent execution = (MojoStartedEvent) entry;
                final Project prj = projects.computeIfAbsent(execution.getArtifactId(), Project::new);
                prj.runningExecution = execution;
                break;
            }
            case Message.PROJECT_STOPPED: {
                StringMessage be = (StringMessage) entry;
                final String artifactId = be.getMessage();
                Project prj = projects.remove(artifactId);
                if (prj != null) {
                    prj.log.forEach(log);
                }
                doneProjects++;
                displayDone();
                break;
            }
            case Message.BUILD_STATUS: {
                this.buildStatus = ((StringMessage) entry).getMessage();
                break;
            }
            case Message.BUILD_FINISHED: {
                projects.values().stream().flatMap(p -> p.log.stream()).forEach(log);
                clearDisplay();
                try {
                    log.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                } finally {
                    terminal.flush();
                }
                return false;
            }
            case Message.KEEP_ALIVE: {
                break;
            }
            case Message.DISPLAY: {
                clearDisplay();
                Message.ProjectEvent d = (Message.ProjectEvent) entry;
                terminal.writer().printf("[%s] %s%n", d.getProjectId(), d.getMessage());
                break;
            }
            case Message.PRINT_OUT: {
                Message.StringMessage d = (Message.StringMessage) entry;
                if (log instanceof FileLog) {
                    log.accept(d.getMessage());
                } else {
                    clearDisplay();
                    System.out.printf("%s%n", d.getMessage());
                }
                break;
            }
            case Message.PRINT_ERR: {
                Message.StringMessage d = (Message.StringMessage) entry;
                if (log instanceof FileLog) {
                    log.accept(d.getMessage());
                } else {
                    clearDisplay();
                    System.err.printf("%s%n", d.getMessage());
                }
                break;
            }
            case Message.PROMPT: {
                Message.Prompt prompt = (Message.Prompt) entry;
                if (dumb) {
                    terminal.writer().println("");
                    break;
                }
                clearDisplay();
                inputHandler.requestPrompt(prompt);
                break;
            }
            case Message.BUILD_LOG_MESSAGE: {
                StringMessage sm = (StringMessage) entry;
                log.accept(sm.getMessage());
                break;
            }
            case Message.PROJECT_LOG_MESSAGE: {
                final ProjectEvent bm = (ProjectEvent) entry;
                final Project prj = projects.get(bm.getProjectId());
                if (prj == null) {
                    log.accept(bm.getMessage());
                } else if (noBuffering || dumb) {
                    String msg;
                    if (maxThreads > 1) {
                        msg = String.format("[%s] %s", bm.getProjectId(), bm.getMessage());
                    } else {
                        msg = bm.getMessage();
                    }
                    log.accept(msg);
                } else {
                    prj.log.add(bm.getMessage());
                }
                break;
            }
            case Message.KEYBOARD_INPUT: {
                char keyStroke = ((StringMessage) entry).getMessage().charAt(0);
                switch (keyStroke) {
                    case KEY_PLUS:
                        linesPerProject = Math.min(10, linesPerProject + 1);
                        break;
                    case KEY_MINUS:
                        linesPerProject = Math.max(0, linesPerProject - 1);
                        break;
                    case KEY_CTRL_B:
                        noBuffering = !noBuffering;
                        if (noBuffering) {
                            applyNoBuffering();
                        } else {
                            clearDisplay();
                        }
                        break;
                    case KEY_CTRL_L:
                        clearDisplay();
                        break;
                    case KEY_CTRL_M:
                        displayDone = !displayDone;
                        displayDone();
                        break;
                }
                break;
            }
            case Message.TRANSFER_INITIATED:
            case Message.TRANSFER_STARTED:
            case Message.TRANSFER_PROGRESSED: {
                final TransferEvent te = (TransferEvent) entry;
                transfers
                        .computeIfAbsent(orEmpty(te.getProjectId()), p -> new LinkedHashMap<>())
                        .put(te.getResourceName(), te);
                break;
            }
            case Message.TRANSFER_CORRUPTED:
            case Message.TRANSFER_SUCCEEDED:
            case Message.TRANSFER_FAILED: {
                final TransferEvent te = (TransferEvent) entry;
                transfers
                        .computeIfAbsent(orEmpty(te.getProjectId()), p -> new LinkedHashMap<>())
                        .remove(te.getResourceName());
                break;
            }
            case Message.EXECUTION_FAILURE: {
                final ExecutionFailureEvent efe = (ExecutionFailureEvent) entry;
                failures.add(efe);
                break;
            }
            case Message.REQUEST_INPUT: {
                RequestInput ri = (RequestInput) entry;
                inputHandler.requestProjectInput(ri.getProjectId(), ri.getBytesToRead());
                break;
            }
            case Message.INPUT_DATA: {
                daemonDispatch.accept(entry);
                break;
            }
            default:
                throw new IllegalStateException("Unexpected message " + entry);
        }

        return true;
    }