MappingFileManager.java

package org.objectweb.jonas_ws.deployment.lib;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.jar.JarFile;

import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.digester.JDigester;

import org.objectweb.jonas_ws.deployment.api.MappingFile;
import org.objectweb.jonas_ws.deployment.api.WSDeploymentDescException;
import org.objectweb.jonas_ws.deployment.rules.JavaWsdlMappingRuleSet;
import org.objectweb.jonas_ws.deployment.xml.JavaWsdlMapping;

import org.objectweb.jonas.common.Log;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;


public class MappingFileManager {

    private static JDigester mfDigester = null;

    private static JavaWsdlMappingRuleSet mfRuleSet = new JavaWsdlMappingRuleSet();

    private static boolean parsingWithValidation = true;

    private static Logger logger = Log.getLogger(Log.JONAS_WS_PREFIX);

    private MappingFileManager() { }

    public static MappingFile getInstance(File module, String filename)
        throws WSDeploymentDescException {
        InputStream is = openStream(module, filename);
        return new MappingFile(loadMappingFile(new InputStreamReader(is), filename));
    }

    public static MappingFile getInstance(Reader r, String filename, boolean validate)
        throws WSDeploymentDescException {
        parsingWithValidation = validate;
        return new MappingFile(loadMappingFile(r, filename));
    }
    public static MappingFile getInstance(InputStream is, String filename)
        throws WSDeploymentDescException {
        return new MappingFile(loadMappingFile(new InputStreamReader(is), filename));
    }


    private static InputStream openStream(File module, String filename)
        throws WSDeploymentDescException {

        InputStream isMapping = null;

        // If we have file stored in Jar
        if (module.exists()) {
            // If we have file stored in Jar
            if (module.isFile()) {
                JarFile jf = null;

                // Get the Mapping file of the jar as InputStream
                try {
                    jf = new JarFile(module.getAbsolutePath());
                    isMapping = jf.getInputStream(jf.getEntry(filename));
                } catch (Exception e) {
                    if (jf != null) {
                        try {
                            jf.close();
                        } catch (IOException i) {
                            logger.log(BasicLevel.WARN, "Can't close '" + module + "'");
                        }
                    }

                    throw new WSDeploymentDescException("Cannot read the jaxrpc-mapping-file "
                                                        + filename + " in " +  module.getAbsolutePath(),
                                                        e);
                }
            } else {
                // filename is a Directory
                try {
                    isMapping =
                        new FileInputStream(new File(module, filename));
                } catch (IOException ioe) {
                    throw new WSDeploymentDescException("Cannot read the jaxrpc-mapping-file "
                                                        + filename + " in " + module.getAbsolutePath(),
                                                        ioe);
                }
            }

        } else {
            // try laoding from ClassLoader
            ClassLoader loader = Thread.currentThread().getContextClassLoader();
            isMapping = loader.getResourceAsStream(filename);
        }

        return isMapping;
    }

    private static JavaWsdlMapping loadMappingFile(Reader reader, String fileName)
        throws WSDeploymentDescException {

        JavaWsdlMapping jwm = new JavaWsdlMapping();

        // Create if mfDigester is null
        if (mfDigester == null) {
            try {
                // Create and initialize the digester
                mfDigester = new JDigester(mfRuleSet,
                                           parsingWithValidation,
                                           true,
                                           null,
                                           new JaxrpcMappingSchemas());
            } catch (DeploymentDescException  e) {
                throw new WSDeploymentDescException(e);
            }
        }

        try {
            mfDigester.parse(reader, fileName, jwm);
        } catch (DeploymentDescException  e) {
            throw new WSDeploymentDescException(e);
        } finally {
            mfDigester.push(null);
        }

        return jwm;
    }

    public static boolean isParsingWithValidation() {
        return parsingWithValidation;
    }

    public static void setParsingWithValidation(boolean parsingWithValidation) {
        MappingFileManager.parsingWithValidation = parsingWithValidation;
    }
}

---