source: java/Framclipse/com.framsticks.framclipse/src/com/framsticks/framclipse/script/XMLConstantProvider.java @ 440

package com.framsticks.framclipse.script;

import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.antlr.misc.MultiMap;
import org.apache.commons.io.IOUtils;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.osgi.framework.Bundle;

import com.framsticks.framclipse.script.context.Context;
import com.framsticks.framclipse.script.context.File;
import com.framsticks.framclipse.script.context.Framscontext;
import com.framsticks.framclipse.script.model.Framscript;
import com.framsticks.framclipse.script.model.Type;
import com.google.common.collect.Maps;
import com.google.inject.Inject;
import com.thoughtworks.xstream.XStream;

public class XMLConstantProvider implements ConstantProvider {

        private static final Bundle BUNDLE = Platform.getBundle("com.framsticks.framclipse");
        private static final ILog LOG = Platform.getLog(BUNDLE);

        private final static Map<String, Type> COMMON_TYPES;
        static {
                Map<String, Type> nullContext = new HashMap<String, Type>(Type.BUILT_IN.length);
                for (Type t : Type.BUILT_IN) {
                        nullContext.put(t.getName(), t);
                }
                COMMON_TYPES = Collections.unmodifiableMap(nullContext);
        }

        private final Map<String, Map<String, Type>> types;

        @Inject
        public XMLConstantProvider(XStream xstream) {
                Framscript framscript = loadFile(xstream, "framscript.xml");
                Framscontext framscontext = loadFile(xstream, "framscontext.xml");
                if (framscript != null && framscontext != null) {
                        types = createTypeMappings(framscontext, framscript);
                } else {
                        types = Collections.emptyMap();
                }
        }

        @SuppressWarnings("unchecked")
        private <T> T loadFile(XStream xstream, String filename) {
                InputStream input = null;
                try {
                        input = BUNDLE.getResource(filename).openStream();
                        return (T) xstream.fromXML(input);
                } catch (IOException e) {
                        LOG.log(new Status(IStatus.ERROR, BUNDLE.getSymbolicName(), e.getLocalizedMessage()));
                        return null;
                } finally {
                        IOUtils.closeQuietly(input);
                }
        }

        private Map<String, Map<String, Type>> createTypeMappings(Framscontext framscontext, Framscript framscript) {
                Map<String, Map<String, Type>> types = Maps.newHashMap();
                MultiMap<String, String> ext2ctx = ext2Ctx(framscontext);
                MultiMap<String, Type> ctx2type = ctx2Type(framscript);
                for (String ext : ext2ctx.keySet()) {
                        HashMap<String, Type> map = new HashMap<String, Type>();
                        types.put(ext, map);
                        for (String ctx : ext2ctx.get(ext)) {
                                for (Type type : ctx2type.get(ctx)) {
                                        map.put(type.getName(), type);
                                }
                        }
                }
                return types;
        }

        private MultiMap<String, String> ext2Ctx(Framscontext framscontext) {
                MultiMap<String, String> ext2ctx = new MultiMap<String, String>();
                for (File file : framscontext.getFiles()) {
                        String ext = file.getPattern();
                        ext = ext.substring(ext.lastIndexOf('.') + 1, ext.length());
                        if (file.getCode() != null) {
                                for (Context context : file.getCode().getContexts()) {
                                        ext2ctx.map(ext, context.getName());
                                }
                        }
                }
                return ext2ctx;
        }

        private MultiMap<String, Type> ctx2Type(Framscript framscript) {
                MultiMap<String, Type> ctx2type = new MultiMap<String, Type>();
                for (Type type : framscript.getTypes()) {
                        ctx2type.map(type.getContext(), type);
                }
                return ctx2type;
        }

        @Override
        public Type getType(String name, String extension) {
                Map<String, Type> types = this.types.get(extension);
                Type result = types != null ? types.get(name) : null;
                return result != null ? result : COMMON_TYPES.get(name);
        }

        @Override
        public Map<String, Map<String, Type>> getTypes() {
                return types;
        }

}