cdc.applic.tools.ApplicConsistencyChecker Maven / Gradle / Ivy

Go to download
package cdc.applic.tools;

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import cdc.applic.consistency.ConsistencyChecker;
import cdc.applic.consistency.core.ConsistencyCheckerImpl;
import cdc.applic.consistency.impl.Block;
import cdc.applic.consistency.impl.ConsistencyDataImpl;
import cdc.applic.consistency.impl.Node;
import cdc.applic.consistency.impl.Reference;
import cdc.applic.consistency.impl.io.ConsistencyDataIO;
import cdc.applic.dictionaries.impl.RepositoryImpl;
import cdc.applic.dictionaries.impl.io.RepositoryIo;
import cdc.issues.Issue;
import cdc.issues.impl.IssuesAndAnswersImpl;
import cdc.issues.io.IssuesIoFactoryFeatures;
import cdc.issues.io.IssuesWriter;
import cdc.issues.io.OutSettings;
import cdc.util.cli.AbstractMainSupport;
import cdc.util.cli.MainResult;
import cdc.util.events.ProgressController;
import cdc.util.lang.FailureReaction;

public final class ApplicConsistencyChecker {
    private static final Logger LOGGER = LogManager.getLogger(ApplicConsistencyChecker.class);
    private final MainArgs margs;

    private ApplicConsistencyChecker(MainArgs margs) {
        this.margs = margs;
    }

    public static class MainArgs {
        public File repositoryFile;
        public File dataFile;
        public File issuesFile;
    }

    void execute() throws IOException {
        final RepositoryImpl repository = RepositoryIo.load(margs.repositoryFile, FailureReaction.FAIL);
        final ConsistencyDataImpl data = ConsistencyDataIO.load(margs.dataFile, repository);
        final ConsistencyChecker checker = new ConsistencyCheckerImpl<>();
        final List issues = checker.check(data);

        IssuesWriter.save(new IssuesAndAnswersImpl().addIssues(issues),
                          OutSettings.ALL_DATA_NO_ANSWERS,
                          margs.issuesFile,
                          ProgressController.VOID,
                          IssuesIoFactoryFeatures.UTC_BEST);
    }

    public static void execute(MainArgs margs) throws IOException {
        final ApplicConsistencyChecker instance = new ApplicConsistencyChecker(margs);
        instance.execute();
    }

    public static MainResult exec(String... args) {
        final MainSupport support = new MainSupport();
        support.main(args);
        return support.getResult();
    }

    public static void main(String... args) {
        final int code = exec(args).getCode();
        System.exit(code);
    }

    private static class MainSupport extends AbstractMainSupport {
        private static final String DATA = "data";
        private static final String ISSUES = "issues";
        private static final String REPOSITORY = "repository";

        protected MainSupport() {
            super(ApplicConsistencyChecker.class,
                  LOGGER);
        }

        @Override
        protected String getVersion() {
            return Config.VERSION;
        }

        @Override
        protected boolean addArgsFileOption(Options options) {
            return true;
        }

        @Override
        protected void addSpecificOptions(Options options) {
            options.addOption(Option.builder()
                                    .longOpt(REPOSITORY)
                                    .desc("Name of the repository file to load.")
                                    .hasArg()
                                    .required()
                                    .build());
            options.addOption(Option.builder()
                                    .longOpt(DATA)
                                    .desc("Name of the data file to load.")
                                    .hasArg()
                                    .required()
                                    .build());
            options.addOption(Option.builder()
                                    .longOpt(ISSUES)
                                    .desc("Name of the issues file to generate.")
                                    .hasArg()
                                    .required()
                                    .build());
        }

        @Override
        protected MainArgs analyze(CommandLine cl) throws ParseException {
            final MainArgs margs = new MainArgs();

            margs.repositoryFile = getValueAsFile(cl, REPOSITORY, IS_FILE);
            margs.dataFile = getValueAsFile(cl, DATA, IS_FILE);
            margs.issuesFile = getValueAsFile(cl, ISSUES);

            return margs;
        }

        @Override
        protected Void execute(MainArgs margs) throws Exception {
            ApplicConsistencyChecker.execute(margs);
            return null;
        }
    }
}