source: java/main/src/main/java/com/framsticks/parsers/Parser.java @ 77

package com.framsticks.parsers;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

import com.framsticks.params.PropertiesAccess;
import org.apache.log4j.Logger;

import com.framsticks.params.FramsClass;
import com.framsticks.params.AccessInterface;

/**
 * The class Parser is used to parse genotype encoded in f0 representation.
 */
public class Parser {

        private final static Logger logger = Logger.getLogger(Parser.class);

        /** The schema proper for f0 representation. */
        private Schema schema;

        public Parser(Schema schema) {
                if (schema == null)
                        throw new NullPointerException(
                                        "Schema object passed to Parser object cannot be null!");
                this.schema = schema;
        }

        /**
         * Parses the stream with genotype in f0 representation. The correctness of
         * genotype is checked. IO and syntax exceptions interrupts parsing and no
         * result is returned. Other exceptions, connected with schema validation
         * cause that certain object or it's parameter is ignored (appropriate
         * communicate informs user about it). Inappropriate values in numeric
         * fields (bigger than maximum or smaller than minimum values) are
         * communicated by warnings and set to minimum / maximum value.
         * 
         * @param is
         *            the is
         * @return the list
         * @throws IOException
         *             Signals that an I/O exception has occurred.
         * @throws ParseException
         *             the parse exception
         */
        public List<AccessInterface> parse(InputStream is) throws IOException,
                        ParseException {
                List<AccessInterface> result = new ArrayList<AccessInterface>();

                InputStreamReader isr = null;
                try {
                        isr = new InputStreamReader(is, "UTF-8");
                        BufferedReader br = new BufferedReader(isr);
                        int l = 0;
                        while (br.ready()) {
                                String line = br.readLine();
                                if (line == null)
                                        line = "";
                                else
                                        line = line.trim();
                                if (l == 0) {
                                        if (!"//0".equals(line)) {
                                                logger.warn("stream should begin with \"//0\" in first line");
                                        } else {
                                                l++;
                                                continue;
                                        }
                                }
                                if (line.equals("")) {
                                        l++;
                                        continue;
                                }
                                try {
                                        int indexOfColon = line.indexOf(':');
                                        if (indexOfColon < 0) {
                                                indexOfColon = line.length();
                                        }
                                        String classId = line.substring(0, indexOfColon).trim();
                                        FramsClass framsClass = schema.getMainClasses()
                                                        .get(classId);
                                        if (framsClass == null)
                                                throw new Exception("Unknown class getId: " + classId);
                                        PropertiesAccess propertiesParam = new PropertiesAccess(framsClass);
                    propertiesParam.select(propertiesParam.createAccessee());
                                        List<Exception> exceptions = propertiesParam.load2(line);
                                        for (Exception e : exceptions) {
                                                logger.warn("In line "
                                                                                + Integer.valueOf(l + 1)
                                                                                + " the following error occured (however entry was added): "
                                                                                + e.getMessage());
                                        }
                                        result.add(propertiesParam);
                                } catch (Exception e) {
                                        logger.warn("In line "
                                                                        + Integer.valueOf(l + 1)
                                                                        + " the following error occured (entry was not added): "
                                                                        + e.getMessage());
                                } finally {
                                        l++;
                                }
                        }
                } finally {
                        if (isr != null)
                                isr.close();
                }

                return result;
        }
}