EntitybuilderConfig.java

/*
 *    ALMA - Atacama Large Millimiter Array
 *    (c) European Southern Observatory, 2002
 *    Copyright by ESO (in the framework of the ALMA collaboration),
 *    All rights reserved
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 2.1 of the License, or (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
 *    MA 02111-1307  USA
 */
package alma.tools.entitybuilder;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.exolab.castor.xml.Unmarshaller;
import org.xml.sax.InputSource;

import alma.tools.entitybuilder.generated.EntitySchema;
import alma.tools.entitybuilder.generated.EntitybuilderSettings;
import alma.tools.entitybuilder.generated.XmlNamespace2JPackage;


/**
 * @author hsommer
 */
public class EntitybuilderConfig
{
	private EntitybuilderSettings m_entitybuilderSettings;
	
    /** key = schema file name w/o path, value = Java package */
    private Map<String, String> m_schema2pckMap = new HashMap<String, String>();

    /** key = xsd namespace, value = Java package */
	private Map<String, String> m_ns2pckMap = new HashMap<String, String>();
	
	private Map<String, File> m_schemaName2File = new HashMap<String, File>();


	/**
	 * Reads the configuration data.
	 * @throws BindingException
	 */
	public void load(File configFile, File[] includeConfigFiles)
			throws BindingException
	{	
		m_entitybuilderSettings = parseConfigFile(configFile);
		storePckgMappings(m_entitybuilderSettings, configFile.getParentFile());
		
		for (File includeConfigFile : includeConfigFiles) {
			EntitybuilderSettings ebs = parseConfigFile(includeConfigFile);
			storePckgMappings(ebs, includeConfigFile.getParentFile());
		}        
	}

    private void storePckgMappings(EntitybuilderSettings ebs, File schemaBaseDir)
	{
		for (XmlNamespace2JPackage mapping : ebs.getXmlNamespace2JPackage()) {
			String namespace = mapping.getXmlNamespace();
			String jPackage = mapping.getJPackage();
			m_ns2pckMap.put(namespace, jPackage);
		}
        
        for (EntitySchema schema : ebs.getEntitySchema()) {
            String schemaName = schema.getSchemaName();
            String namespace = schema.getXmlNamespace();
            String jPackage = m_ns2pckMap.get(namespace); 
            m_schema2pckMap.put(schemaName, jPackage);
            
            String relPath = schema.getRelativePathSchemafile();
			if (relPath.trim().length() == 0 || relPath.equals(".")) {
				relPath = File.separator;
			}
			else {
				relPath = File.separator + relPath + File.separator;
			}
			String absPathName = schemaBaseDir.getAbsolutePath() + relPath + schema.getSchemaName();
			File schemaFile = new File(absPathName);
			if (schemaFile.exists()) {
	            m_schemaName2File.put(schemaName, schemaFile);
			}
			else {
				System.err.println("specified schema file '" + absPathName + "' does not exist; will be ignored.");
			}            
        }
	}

    
    /**
     * Gets all xsd namespaces, even those from included config files for which no code is generated directly.
     */
    public String[] getAllNamespaces()
    {
        return m_ns2pckMap.keySet().toArray(new String[1]);
    }
    
    public String getJPackageForNamespace(String ns) 
    {
        String jPackage = m_ns2pckMap.get(ns);
        return jPackage;
    }
    

    /**
     * Gets all schema names, even those from included config files for which no code is generated directly.
     * Only file names, no directory path.
     */
    public String[] getAllSchemaNames()
    {
        return m_schema2pckMap.keySet().toArray(new String[1]);
    }
    
    public String getJPackageForSchema(String schemaName) 
    {
        String jPackage = m_schema2pckMap.get(schemaName);
        return jPackage;
    }
    
	
	/**
     * Gets all schema files which should be run explicitly through the code generator.
     * Schema files that are only used indirectly (include, import) are not returned.
	 */
	public List<File> getPrimarySchemaFiles() throws BindingException {
		ArrayList<File> schemaList = new ArrayList<File>();
		for (EntitySchema schema : m_entitybuilderSettings.getEntitySchema()) {
			File schemaFile = m_schemaName2File.get(schema.getSchemaName());
			if (schemaFile != null) {
				schemaList.add(schemaFile);
			}
			else {
				String msg = "specified schema file " + schema.getSchemaName() + " does not exist.";
				System.err.println(msg + " Will be ignored.");
//				throw new BindingException(msg; will be ignored.);
			}
		}
		return schemaList;
	}

    public List<File> getAllSchemaFiles() {
    	return new ArrayList<File>(m_schemaName2File.values());
    }
    
    public Map<String, File> getSchemaName2File() {
    	return Collections.unmodifiableMap(m_schemaName2File);
    }

    private EntitybuilderSettings parseConfigFile(File configFile) throws BindingException
    {
        EntitybuilderSettings ebs = null;
        InputStream is = null;
        
        try {
            is = new FileInputStream(configFile);
        }
        catch (Exception e) {
        }
        
        if (is == null) {
            throw new BindingException("xml config file '" + configFile.getAbsolutePath() + "' not found.");
        }
        
        try {
            ebs = (EntitybuilderSettings) Unmarshaller.unmarshal(
                        EntitybuilderSettings.class, new InputSource(is));
        }
        catch (Exception e) {
            String msg = "parsing of schema config file failed. ";
            throw new BindingException(msg, e);
        }
        
        return ebs;
    }
    



//    private void generateXmlTemplate(File xmlFile)
//			throws BindingException
//	{
//		EntitybuilderSettings ebs = new EntitybuilderSettings();
//
//		EntitySchema es1 = new EntitySchema();
//		ebs.addEntitySchema(es1);
//		es1.setSchemaName("ObsProject.xsd");
//		es1.setXmlNamespace("Alma/ObsProject");
//
//		XmlNamespace2JPackage nsp = new XmlNamespace2JPackage();
//		ebs.addXmlNamespace2JPackage(nsp);
//		nsp.setXmlNamespace("Alma/ObsProject");
//		nsp.setJPackage("alma.entity.xmlbinding.obsproject");
//		
//		try
//		{
//			Marshaller.marshal(ebs, new FileWriter(xmlFile));
//		}
//		catch (Exception e)
//		{
//			throw new BindingException("marshalling error: ", e);
//		}
//	}

}