source: java/main/src/main/java/com/framsticks/parsers/MultiParamLoader.java @ 103

package com.framsticks.parsers;

import com.framsticks.params.*;
import com.framsticks.util.Misc;

import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import java.util.*;

public class MultiParamLoader {

        public interface StatusListener {
                void onStatusChange();
        }

        private final static Logger log = LogManager.getLogger(MultiParamLoader.class);

        /**
         * The class which name was recently found in the file, to which execution
         * should be passed.
         */
        public Access getLastAccess() {
                return lastAccess;
        }

        /**
         * Specifies the condition to break execution.
         */
        public enum Status {
                None, Finished, BeforeObject, AfterObject, BeforeUnknown, OnComment, OnError, Loading
        }

        protected final Map<Status, List<StatusListener>> listeners = new HashMap<>();

        /**
         * Specifies the action that should be taken inside loops.
         */
        private enum LoopAction {
                Nothing, Break, Continue
        }

        protected Access lastAccess;

        protected static final FramsClass emptyFramsClass = FramsClass.build().idAndName("<empty>").finish();
        /**
         * Empty Param representing unknown classes - used to omit unknown
         * objects in the file.
         */
        protected Access emptyParam = new PropertiesAccess(emptyFramsClass);

        /**
         * Last comment found in the file.
         */
        protected String lastComment;

        /**
         * Set of break conditions.
         */
        private EnumSet<Status> breakConditions = EnumSet.of(Status.None);

        /**
         * Status of current execution.
         */
        private Status status = Status.None;


        /**
         * File from which data should be read.
         */
        private Source currentSource;

        protected String currentLine;


        /**
         * All the files read by the loader (there could be many of them because of
         * '#|include').
         */
        private Stack<String> fileStack = new Stack<String>();

        /**
         * A map that specifies connection between the getName of the file and the
         * actual reader.
         */
        private Map<String, Source> fileMap = new HashMap<String, Source>();

        /**
         * List of known classes.
         */
        protected AccessProvider accessProvider = null;

        /**
         * Last unknown object found in the file.
         */
        private String lastUnknownObjectName;

        /**
         * @return the currentLine
         */
        public String getCurrentLine() {
                return currentLine;
        }

        /**
         * @return the accessProvider
         */
        public AccessProvider getAccessProvider() {
                return accessProvider;
        }

        /**
         * @param accessProvider the accessProvider to set
         */
        public void setAccessProvider(AccessProvider accessProvider) {
                this.accessProvider = accessProvider;
        }

        public MultiParamLoader() {

        }

        /**
         * Starts reading the file.
         */
        public Status go() {
                Misc.throwIfNull(accessProvider);
                log.trace("go");

                while (!isFinished()) {
                        // check if we are before some known or unknown object
                        LoopAction loopAction = tryReadObject();
                        if (loopAction == LoopAction.Break) {
                                break;
                        } else if (loopAction == LoopAction.Continue) {
                                continue;
                        }

                        // read data
                        currentLine = currentSource.readLine();

                        // end of file
                        if (currentLine == null) {
                                if (!returnFromIncluded()) {
                                        finish();
                                        break;
                                } else {
                                        continue;
                                }
                        }
                        log.trace("read line: {}", currentLine);

                        // empty line
                        if (currentLine.length() == 0) {
                                continue;
                        }

                        // check if some file should be included
                        if (isIncludeLine(currentLine) == LoopAction.Continue) {
                                continue;
                        }

                        // check if should break on comment
                        if (isCommentLine(currentLine) == LoopAction.Break) {
                                break;
                        }

                        // get class getName
                        LoopAction action = changeCurrentParamInterface(currentLine);
                        if (action == LoopAction.Break) {
                                break;
                        }
                        if (action == LoopAction.Continue) {
                                continue;
                        }

                        // log.warn("unknown line: {}", currentLine);
                        changeStatus(Status.OnError);
                        if (action == LoopAction.Break) {
                                break;
                        }
                        if (action == LoopAction.Continue) {
                                continue;
                        }
                }

                return status;
        }

        /**
         * Checks whether the reader found a known or unknown object and execution
         * should be passed to it.
         * @throws Exception
         */
        private LoopAction tryReadObject() {
                if (status == Status.BeforeObject || (status == Status.BeforeUnknown && lastAccess != null)) {
                        // found object - let it load data
                        if (lastAccess.getSelected() == null) {
                                lastAccess.select(lastAccess.createAccessee());
                        }
                        log.trace("loading into {}", lastAccess);
                        AccessOperations.load(lastAccess, currentSource);

                        if (changeStatus(Status.AfterObject)) {
                                return LoopAction.Break;
                        }
                        return LoopAction.Continue;
                } else if (status == Status.BeforeUnknown) {
                        log.warn("omitting unknown object: {}", lastUnknownObjectName);

                        // found unknown object
                        AccessOperations.load(emptyParam, currentSource);
                        if (changeStatus(Status.AfterObject)) {
                                return LoopAction.Break;
                        }
                        return LoopAction.Continue;
                }

                return LoopAction.Nothing;
        }

        /**
         * Checks whether some additional file shouldn't be included.
         */
        private LoopAction isIncludeLine(String line) {
                try {
                        // found comment
                        if (line.charAt(0) == '#') {
                                // maybe we should include something
                                if (line.substring(1, 8).equals("include")) {
                                        int beg = line.indexOf('\"');
                                        if (beg == -1) {
                                                log.info("Wanted to include some file, but the format is incorrect");
                                                return LoopAction.Continue;
                                        }

                                        String includeFileName = line.substring(beg + 1);
                                        int end = includeFileName.indexOf('\"');
                                        if (end == -1) {
                                                log.info("Wanted to include some file, but the format is incorrect");
                                                return LoopAction.Continue;
                                        }

                                        includeFileName = includeFileName.substring(0, end);

                                        include(includeFileName);

                                        return LoopAction.Continue;
                                }
                        }
                } catch (IndexOutOfBoundsException ex) {
                        // value after # sign is shorter than expected 7 characters - do
                        // nothing
                }

                return LoopAction.Nothing;
        }

        /**
         * Checks whether execution shouldn't break on comment.
         */
        private LoopAction isCommentLine(String line) {
                if (line.charAt(0) == '#') {
                        lastComment = line;
                        if (changeStatus(Status.OnComment)) {
                                // it's a simple comment - maybe we should break?
                                return LoopAction.Break;
                        }
                }
                return LoopAction.Nothing;
        }

        /**
         * Gets the getName of the class from line read from file.
         */
        private LoopAction changeCurrentParamInterface(String line) {
                // found key - value line
                if (line.charAt(line.length() - 1) == ':') {
                        String typeName = line.substring(0, line.length() - 1);
                        lastAccess = accessProvider.getAccess(typeName);

                        if (lastAccess != null) {
                                if (changeStatus(Status.BeforeObject)) {
                                        return LoopAction.Break;
                                } else {
                                        return LoopAction.Continue;
                                }
                        } else {
                                lastUnknownObjectName = typeName;
                                if (changeStatus(Status.BeforeUnknown)) {
                                        return LoopAction.Break;
                                } else {
                                        return LoopAction.Continue;
                                }
                        }
                }
                return LoopAction.Nothing;
        }

        /**
         * Adds another break condition.
         */
        public void addBreakCondition(Status condition) {
                breakConditions.add(condition);
        }

        /**
         * Removes break condition.
         */
        public void removeBreakCondition(Status condition) {
                breakConditions.remove(condition);
        }

        /**
         * Checks whether execution is finished.
         */
        private boolean isFinished() {
                return (status == Status.Finished);
        }

        private void finish() {
                log.trace("finishing");
                if (currentSource != null) {
                        currentSource.close();
                }

                changeStatus(Status.Finished);
        }

        /**
         * Opens selected file.
         */

        public boolean setNewSource(Source source) {
                log.debug("switching current source to {}...", source.getFilename());

                currentSource = source;
                changeStatus(Status.Loading);

                return true;
        }

        /**
         * Includes specified file.
         */
        private void include(String includeFilename) {

                includeFilename = currentSource.demangleInclude(includeFilename);

                if (includeFilename == null) {
                        return;
                }
                // check if it is already included and break if it is
                if (isAlreadyIncluded(includeFilename)) {
                        log.debug("circular reference ignored ({})", includeFilename);
                        return;
                }

                log.info("including file {}...", includeFilename);

                Source newSource = currentSource.openInclude(includeFilename);
                if (newSource == null) {
                        return;
                }

                fileStack.add(currentSource.getFilename());
                fileMap.put(currentSource.getFilename(), currentSource);
                setNewSource(newSource);

        }

        /**
         * Checks whether selected file was already included.
         */
        private boolean isAlreadyIncluded(String filename) {
                for (String file : fileStack) {
                        if (filename.equals(file)) {
                                log.warn("file {} was already included", filename);
                                return true;
                        }
                }

                return false;
        }

        /**
         * Returns from included file.
         */
        private boolean returnFromIncluded() {
                if (fileStack.size() == 0) {
                        return false;
                }

                if (currentSource != null) {
                        currentSource.close();
                }

                String filename = fileStack.pop();
                currentSource = fileMap.get(filename);
                fileMap.remove(filename);

                return true;
        }

        /**
         * Checks whether execution should break on selected condition.
         */
        private boolean changeStatus(Status status) {
                log.trace("changing status: {} -> {}", this.status.toString(), status.toString());
                this.status = status;
                if (listeners.containsKey(status)) {
                        for (StatusListener l : listeners.get(status)) {
                                l.onStatusChange();
                        }
                }
                return breakConditions.contains(status);
        }

        public Object returnObject() {
                assert lastAccess != null;
                Object result = lastAccess.getSelected();
                if (result == null) {
                        return null;
                }
                lastAccess.select(null);
                return result;
        }

        public void addListener(Status status, StatusListener listener) {
                if (!listeners.containsKey(status)) {
                        listeners.put(status, new LinkedList<StatusListener>());
                }
                listeners.get(status).add(listener);
        }

        public static List<Object> loadAll(Source source, Access access) {
                final List<Object> result = new LinkedList<>();

                final MultiParamLoader loader = new MultiParamLoader();
                loader.setNewSource(source);
                loader.setAccessProvider(new AccessStash().add(access));
                loader.addListener(MultiParamLoader.Status.AfterObject, new StatusListener() {
                        @Override
                        public void onStatusChange() {
                                result.add(loader.returnObject());
                        }
                });
                loader.go();
                return result;
        }
}