AModelManager.java

Go to the documentation of this file.

package jarmos.io;

import jarmos.FieldDescriptor;
import jarmos.IMessageHandler;
import jarmos.Log;
import jarmos.ModelDescriptor;
import jarmos.ModelType;
import jarmos.Parameters;
import jarmos.SolutionFieldType;
import jarmos.geometry.FieldMapping;
import jarmos.io.MathObjectReader.MachineFormats;
import jarmos.util.ConsoleProgressReporter;
import jarmos.util.IProgressReporter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public abstract class AModelManager {

    public class ModelManagerException extends Exception {

        private static final long serialVersionUID = 7411589173897801550L;

        public ModelManagerException(String msg) {
            super(msg);
        }

        public ModelManagerException(String msg, Exception inner) {
            super(msg, inner);
        }

    }

    public static final String CLASSES_JARFILE = "classes.jar";

    public static final String info_filename = "site_info.html";

    private DocumentBuilder db = null;
    private Validator dv = null;
    private String mdir = "notset";
    private List<IMessageHandler> mhandlers;
    private Node modelnode = null;
    private Document modelxml = null;
    private ModelType mtype = ModelType.Unknown;

    private MathObjectReader mor = null;

    public AModelManager() {
        mhandlers = new ArrayList<IMessageHandler>();
        try {
            // Create the document builder
            DocumentBuilderFactory bf = DocumentBuilderFactory.newInstance();
            bf.setIgnoringElementContentWhitespace(true);

            db = bf.newDocumentBuilder();

            InputStream in = getClass().getResourceAsStream("/model.xsd");

            // Create the schema validator (if xsd was found)
            if (in != null) {
                try {
                    SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
                    Schema s = sf.newSchema(new StreamSource(in));
                    // dv = s.newValidator();
                } catch (IllegalArgumentException e) { //
                    /*
                     * See constructor comment on what happens here.. Set Validator to null if the
                     * IllegalArgumentException gets thrown
                     */
                    dv = null;
                }
            } else
                Log.e("AModelManager", "No model.xsd validation resource found!");
        } catch (ParserConfigurationException e) {
            throw new RuntimeException("Error creating a XML document builder", e);
        } catch (SAXException e) {
            throw new RuntimeException("Error creating a XML schema validator", e);
        }
    }

    public void addMessageHandler(IMessageHandler h) {
        mhandlers.add(h);
    }

    public Object loadModelClass(String name) throws ModelManagerException {
        ClassLoader cl = getClassLoader();
        String pkg = getModelPackageStr();
        try {
            Class<?> af = cl.loadClass(pkg + name);
            return af.newInstance();
        } catch (Exception e) {
            throw new ModelManagerException("Error loading the model class '" + name + "' of package '"
                    + (pkg != "" ? pkg : "(default)") + "'.", e);
        }
    }

    public BufferedReader getBufReader(String filename) throws IOException {
        int buffer_size = 8192;

        InputStreamReader isr = new InputStreamReader(getInStream(filename));
        return new BufferedReader(isr, buffer_size);
    }

    public ClassLoader getClassLoader() {
        return ClassLoader.getSystemClassLoader();
    }

    protected abstract String[] getFolderList() throws IOException;

    protected abstract String getLoadingMessage();

    public final InputStream getInStream(String filename) throws IOException {
        int pos = filename.indexOf(".bin");
        sendMessage((pos > -1) ? filename.substring(0, pos) : filename);
        return getInStreamImpl(filename);
    }

    protected abstract InputStream getInStreamImpl(String filename) throws IOException;

    public MathObjectReader getMathObjReader() {
        return mor;
    }

    public List<ModelDescriptor> getModelDescriptors() throws ModelManagerException {
        return getModelDescriptors(new ConsoleProgressReporter());
    }

    public List<ModelDescriptor> getModelDescriptors(IProgressReporter pr) throws ModelManagerException {
        ArrayList<ModelDescriptor> res = new ArrayList<ModelDescriptor>();
        String[] list = null;
        try {
            list = getFolderList();
        } catch (IOException e) {
            throw new ModelManagerException("Listing model folders failed.", e);
        }
        // Set loading message
        pr.init(getLoadingMessage(), list.length);
        int cnt = 0;
        for (String modeldir : list) {
            pr.progress(++cnt);
            if (isValidModelDir(modeldir)) {
                useModel(modeldir);
                // Check for the correct model type
                ModelType mtype = ModelType.parse(getModelXMLAttribute("type"));
                if (mtype == ModelType.Unknown)
                    continue;

                InputStream img = null;
                String imgfile = getModelXMLTagValue("description.image");
                if (modelFileExists(imgfile)) {
                    try {
                        img = getInStream(imgfile);
                    } catch (IOException e) {
                        // ignore
                    }
                } else
                    img = getClass().getClassLoader().getResourceAsStream("notfound.png");
                // Get model date
                Date d = null;
                try {
                    d = DateFormat.getDateInstance().parse(getModelXMLTagValue("description.created"));
                } catch (ParseException e) {
                    d = Calendar.getInstance().getTime();
                }
                ModelDescriptor md = new ModelDescriptor(modeldir, getModelXMLTagValue("description.name"), mtype, img,
                        d);
                md.shortDescription = getModelXMLTagValue("description.short", "");
                res.add(md);
            }
        }
        pr.finish();
        return res;
    }

    public String getModelDir() {
        return mdir;
    }

    public FieldDescriptor[] getModelFieldTypes() {
        FieldDescriptor[] res = null;
        Element params = getModelXMLElement("visual.fields");
        if (params != null) {
            NodeList nl = params.getElementsByTagName("field");
            res = new FieldDescriptor[nl.getLength()];
            String hlp;
            FieldDescriptor f;
            for (int i = 0; i < nl.getLength(); i++) {
                Node n = nl.item(i);
                f = new FieldDescriptor(SolutionFieldType.valueOf(getNodeAttributeValue(n, "type")));
                f.Name = n.getTextContent();
                hlp = getNodeAttributeValue(n, "mapping");
                f.Mapping = hlp != null ? FieldMapping.valueOf(hlp) : FieldMapping.UNKNOWN;
                res[i] = f;
            }
        }
        return res;
    }

    public ModelType getModelType() {
        return mtype;
    }

    public abstract URI getModelURI();

    public String getModelXMLAttribute(String attrib_name) {
        assert attrib_name != null;

        if (modelnode != null) {
            return getNodeAttributeValue(modelnode, attrib_name);
        }
        return null;
    }

    public String getModelXMLAttribute(String attrib_name, String tagname) {
        assert attrib_name != null;
        assert tagname != null;

        Element e = getModelXMLElement(tagname);
        return (e != null) ? getNodeAttributeValue(e, attrib_name) : null;
    }

    // private String[] getXMLElementChildNames(String tags) {
    // String[] res = null;
    // Element parent = getModelXMLElement(tags);
    // if (parent != null) {
    // res = new String[parent.getChildNodes().getLength()];
    // for (int nidx = 0; nidx < res.length; nidx++) {
    // res[nidx] = parent.getChildNodes().item(nidx).getNodeName();
    // }
    // }
    // return res;
    // }

    private Element getModelXMLElement(String tags) {
        if (modelxml != null) {
            Element cur = modelxml.getDocumentElement();
            String[] elems = tags.split("\\.");
            for (String elem : elems) {
                NodeList nl = cur.getElementsByTagName(elem);
                if (nl != null && nl.getLength() > 0) {
                    cur = (Element) nl.item(0);
                } else {
                    cur = null;
                    break;
                }
            }
            if (cur != null) {
                return cur;
            }
        }
        return null;
    }

    public String getModelXMLTagValue(String tagname) {
        return getModelXMLTagValue(tagname, null);
    }

    public String getModelXMLTagValue(String tagname, String default_value) {
        Element res = getModelXMLElement(tagname);
        return (res != null) ? res.getTextContent() : default_value;
    }

    public String getModelPackageStr() {
        String thepackage = getModelXMLTagValue("package");
        return thepackage != null ? thepackage + "." : "";
    }

    private String getNodeAttributeValue(Node n, String attrib_name) {
        assert n != null;
        assert attrib_name != null;

        Node a = n.getAttributes().getNamedItem(attrib_name);
        if (a != null) {
            return a.getNodeValue();
        } else
            return null;
    }

    public Parameters getParameters() {
        Element params = getModelXMLElement("parameters");
        if (params != null) {
            Parameters p = new Parameters();
            NodeList nl = params.getElementsByTagName("param");
            double[] cur = new double[nl.getLength()];
            for (int i = 0; i < nl.getLength(); i++) {
                Node n = nl.item(i);
                String name = getNodeAttributeValue(n, "name");
                // Set \mu_i if no name is given.
                if (name == null) {
                    name = "\u00B5_" + i;
                }
                // Add
                p.addParam(name, Double.parseDouble(getNodeAttributeValue(n, "min")),
                        Double.parseDouble(getNodeAttributeValue(n, "max")));
                // Extract default values and set as current, take min value if
                // no default is set
                String def = getNodeAttributeValue(n, "default");
                cur[i] = def != null ? Double.parseDouble(def) : p.getMinValue(i);
            }
            p.setCurrent(cur);
            return p;
        }
        return null;
    }

    public boolean isValidModelDir(String dir) {
        assert dir != null;

        /*
         * Store current model directory if set, and temporarily set the model dir to dir. This is done as subclass
         * implementations will of course depend on getModelDir() when calling modelFileExists().
         */
        String olddir = mdir;
        mdir = dir;
        if (!modelFileExists("model.xml"))
            return false;
        try {
            try {
                db.parse(getInStream("model.xml"));
            } catch (SAXException e) {
                return false;
            }
            try {
                if (dv != null) {
                    dv.validate(new DOMSource(modelxml));
                }
            } catch (SAXException se) {
                Log.e("AModelManager", "Invalid model.xml: " + se.getMessage(), se);
                return false;
            }
        } catch (IOException e) {
            throw new RuntimeException("I/O error while checking if model directory is valid.", e);
        }
        // Restore old model dir
        mdir = olddir;
        return true;
    }

    public abstract boolean modelFileExists(String filename);

    public void removeMessageHandler(IMessageHandler h) {
        mhandlers.remove(h);
    }

    protected void sendMessage(String msg) {
        for (IMessageHandler h : mhandlers) {
            h.sendMessage(msg);
        }
    }

    public void useModel(String location) throws ModelManagerException {
        assert isValidModelDir(location);

        this.mdir = location;
        Log.d("ModelManager", "Loading model from " + getModelURI());
        try {
            modelxml = db.parse(getInStream("model.xml"));
        } catch (Exception e) {
            throw new ModelManagerException("Unexpected Exception in AModelManager.setModelDir: " + e.getMessage(), e);
        }

        modelxml.normalize();
        modelnode = modelxml.getElementsByTagName("model").item(0);

        String type = getModelXMLAttribute("type");
        mtype = ModelType.parse(type);
        if (mtype == ModelType.Unknown)
            throw new ModelManagerException("Unknown model type: " + type);

        // Parse model data machine format
        mor = new MathObjectReader();
        String machformat = getModelXMLAttribute("machformat");
        if ("le".equals(machformat)) {
            mor.MachineFormat = MachineFormats.LittleEndian;
        } else {
            mor.MachineFormat = MachineFormats.BigEndian;
        }
    }

    public boolean xmlTagExists(String tagname) {
        return getModelXMLElement(tagname) != null;
    }
}