DefaultWSDL2JavaPlugin.java

package org.codehaus.mojo.axistools.wsdl2java;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.axis.wsdl.toJava.Emitter;
import org.apache.maven.artifact.Artifact;
import org.codehaus.mojo.axistools.axis.AbstractAxisPlugin;
import org.codehaus.mojo.axistools.axis.AxisPluginException;
import org.codehaus.mojo.axistools.axis.Mapping;
import org.codehaus.plexus.compiler.util.scan.InclusionScanException;
import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
import org.codehaus.plexus.compiler.util.scan.StaleSourceScanner;
import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.PathTool;
import org.codehaus.plexus.util.StringUtils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.jar.JarEntry;

/**
 * @author: jesse
 * @version: $Id$
 */
public class DefaultWSDL2JavaPlugin
    extends AbstractAxisPlugin
    implements WSDL2JavaPlugin
{
    /**
     * list of urls to process
     *
     * @parameter expression=""
     */
    private ArrayList urls;

    /**
     * List of wsdl files from {@link #sourceDirectory} to process
     *
     * @parameter expression=""
     */
    private ArrayList wsdlFiles;

    /**
     * list of source dependencies in the format groupId:artifactId:version:file
     *
     * @parameter expression=""
     */
    private ArrayList sourceDependencies;

    /**
     * Cache directory for WSDLs from URLs
     *
     * @parameter expression="${project.build.directory}/axistools/wsdl2java/urlDownloads"
     */
    private File urlDownloadDirectory;

    /**
     * Cache directory for WSDLs from sourceDependencies
     *
     * @parameter expression="${project.build.directory}/axistools/wsdl2java/sourceDependencies"
     */
    private File sourceDependencyDirectory;

    /**
     * use the Emitter for generating the java files as opposed to the commandline wsdl2java tool
     *
     * @parameter expression="false"
     */
    private boolean useEmitter;

    /**
     * mappings are only used when useEmitter is set to true
     *
     * @parameter expression=""
     */
    private ArrayList mappings;

    /**
     * @parameter expression="${serverSide}"
     */
    private boolean serverSide;

    /**
     * package to create the java files under
     *
     * @parameter expression="${packageSpace}"
     */
    private String packageSpace;

    /**
     * @parameter expression="${verbose}"
     */
    private boolean verbose;

    /**
     * generate the test cases
     *
     * @parameter expression="${testCases}"
     */
    private boolean testCases;

    /**
     * Copy the generated test cases to a generated-sources test directory to
     * be compiled and run as normal Surefire unit tests.
     *
     * @parameter expression="false"
     */
    private boolean runTestCasesAsUnitTests;

    /**
     * @parameter expression="${allElements}"
     */
    private boolean allElements;

    /**
     * @parameter expression="false"
     */
    private boolean debug;

    /**
     * @parameter expression="${timeout}"
     */
    private Integer timeout;

    /**
     * @parameter expression="false"
     */
    private boolean noImports;

    /**
     * @parameter expression="false"
     */
    private boolean noWrapped;

    /**
     * @parameter expression="true"
     */
    private boolean wrapArrays;

    /**
     * @parameter expression="false"
     */
    private boolean skeletonDeploy;

    /**
     * @parameter expression="${namespaceToPackage}"
     */
    private String namespaceToPackage;

    /**
     * @parameter expression="${fileNamespaceToPackage}"
     */
    private File fileNamespaceToPackage;

    /**
     * @parameter expression="${deployScope}"
     */
    private String deployScope;

    /**
     * @parameter expression="${typeMappingVersion}"
     */
    private String typeMappingVersion;

    /**
     * @parameter expression="${factory}"
     */
    private String factory;

    /**
     * @parameter expression=""
     */
    private ArrayList nsIncludes;

    /**
     * @parameter expression=""
     */
    private ArrayList nsExcludes;

    /**
     * @parameter expression="false"
     */
    private boolean helperGen;

    /**
     * @parameter expression="${username}"
     */
    private String username;

    /**
     * @parameter expression="${password}"
     */
    private String password;

    /**
     * @parameter expression="${implementationClassName}"
     */
    private String implementationClassName;

    /**
     * load.wsdl would further subpackage into load.*
     *
     * @parameter expression="${subPackageByFileName}"
     */
    private boolean subPackageByFileName;

    /**
     * location to place generated test source
     *
     * @parameter expression="${project.build.directory}/generated-test-sources/wsdl"
     */
    private File testSourceDirectory;

    public void execute()
        throws AxisPluginException
    {
        if ( !outputDirectory.exists() )
        {
            outputDirectory.mkdirs();
        }

        getLog().info( "about to add compile source root" );

        if ( project != null )
        {
            project.addCompileSourceRoot( outputDirectory.getAbsolutePath() );
        }

        // Get WSDL files

        if ( urls != null )
        {
            for ( Iterator i = urls.iterator(); i.hasNext(); )
            {
                downloadWSDLFromUrl( (String) i.next() );
            }
        }

        if ( sourceDependencies != null )
        {
            for ( Iterator i = sourceDependencies.iterator(); i.hasNext(); )
            {
                extractWSDLFromSourceDependency( (String) i.next() );
            }
        }

        Set wsdlSet = computeStaleWSDLs();

        if ( wsdlSet.isEmpty() )
        {
            getLog().info( "Nothing to generate. All WSDL files are up to date." );
        }
        else if ( wsdlFiles == null ) 
        {
            for ( Iterator i = wsdlSet.iterator(); i.hasNext(); )
            {
                File wsdl = (File) i.next();

                processWsdl( wsdl );
            }
        }
        else
        {
            // MAXISTOOLS-47: It is important to search this way to be able to
            // respect the order of the WSDL files as specified in the POM, even
            // though it might be a bit slower (searching all files instead of
            // only the stale files)
            for ( Iterator i = wsdlFiles.iterator(); i.hasNext(); )
            {
                String wsdlFileName = (String) i.next();
                File wsdl = getFile( wsdlSet, wsdlFileName );

                // If this file is not among the stale files, skip it 
                if ( wsdl == null )
                {
                    getLog().info( "Skipping up to date wsdl: " + wsdlFileName + "." );
                    continue;
                }

                processWsdl( wsdl );
            }
        }

        if ( runTestCasesAsUnitTests )
        {
            migrateTestSource();
        }
    }

    private void processWsdl( File wsdl )
        throws AxisPluginException
    {
        getLog().info( "Processing wsdl: " + wsdl.toString() );

        if ( !useEmitter )
        {
            WSDL2JavaWrapper wsdlWrapper = new WSDL2JavaWrapper();
            wsdlWrapper.execute( generateWSDLArgumentList( wsdl.getAbsoluteFile() ) );
        }
        else
        {
            runEmitter( wsdl );
        }

        try
        {
            FileUtils.copyFileToDirectory( wsdl, timestampDirectory );
        }
        catch ( IOException e )
        {
            throw new AxisPluginException( "Error while copying the WSDL to timestamp directory.", e );
        }
    }

    /**
     * Find a file with a given name among a set of files.
     * 
     * @param fileSet A set of files
     * @param fileName The name of a file
     * @return The file if it is found, otherwise <code>null</code>
     */
    private File getFile( Set /*<File>*/ fileSet, String fileName )
    {
        for ( Iterator iterator = fileSet.iterator(); iterator.hasNext(); )
        {
            File file = (File) iterator.next();
            if ( file.getName().equals( fileName ) )
            {
                return file;
            }
        }
        return null;
    }

    /**
     * Downloads a missing or stale WSDL from the given URL to the directory
     * {@link #urlDownloadDirectory}.
     * <ul>
     * <li>if the syntax of a URL is invalid
     * <li>if the URL cannot be opened to check the modification timestamp
     * <li>if the URL cannot be downloaded
     * </ul>
     *
     * @param urlStr the WSDL URL
     */
    private void downloadWSDLFromUrl( String urlStr )
        throws AxisPluginException
    {
        URLConnection urlConnection;
        try
        {
            URL url = new URL( urlStr );
            urlConnection = url.openConnection();
        }
        catch ( Exception e )
        {
            throw new AxisPluginException( "unable to open connection for download of WSDL file from URL " + urlStr
                + ". Reason: " + e.getClass().getName() + ": " + e.getMessage(), e );
        }

        File localWsdl = new File( urlDownloadDirectory, createSafeFileName( urlStr ) );
// Compare modification timestamp of the URL against
// that of the local copy.
        if ( localWsdl.exists() && localWsdl.lastModified() == urlConnection.getLastModified() )
        {
            getLog().debug( "local copy of WSDL file from URL " + urlStr + " is up to date." );
            return;
        }

        // The local copy does not exist or it is outdated.
        // Copy the file from the URL to disk

        if ( !urlDownloadDirectory.exists() )
        {
            urlDownloadDirectory.mkdirs();
        }

        InputStream urlInput = null;
        OutputStream localWsdlOutput = null;
        try
        {
            urlInput = urlConnection.getInputStream();
            localWsdlOutput = new FileOutputStream( localWsdl );

            IOUtil.copy( urlInput, localWsdlOutput );
            localWsdlOutput.flush();

            getLog().info( "downloaded WSDL from URL " + urlStr + " (" + localWsdl.length() + " Bytes)." );

        }
        catch ( Exception e )
        {
            throw new AxisPluginException( "unable to download WSDL file from " + urlStr + " to "
                + localWsdl.getAbsolutePath() + ". Reason: " + e.getClass().getName() + ": " + e.getMessage(), e );
        }
        finally
        {
            IOUtil.close( urlInput );
            IOUtil.close( localWsdlOutput );
        }

        localWsdl.setLastModified( urlConnection.getLastModified() );
    }

    /**
     * Extracts a stale or missing WSDL from the artifact referenced via the
     * given source dependency name to the directory
     * {@link #sourceDependencyDirectory}.
     * <p/>
     * <ul>
     * <li>if the sourceDependency format is invalid
     * <li>if the referenced artifact JAR file cannot be opened
     * <li>if the referenced WSDL file cannot be found or retrieved from the referenced artifact
     * </ul>
     *
     * @param sourceDependencyString the source dependency (in the format <code>groupId:artifactId:version:file</code>)
     */
    private void extractWSDLFromSourceDependency( String sourceDependencyString )
        throws AxisPluginException
    {
        StringTokenizer strtok = new StringTokenizer( sourceDependencyString, ":" );

        if ( strtok.countTokens() != 4 )
        {
            throw new AxisPluginException( "invalid sourceDependency: " + sourceDependencyString
                + ". Expected format: groupId:artifactId:version:file" );
        }

        String groupId = strtok.nextToken();
        String artifactId = strtok.nextToken();
        String version = strtok.nextToken();
        String wsdlFileString = strtok.nextToken();

        JarEntry entry;
        JarURLConnection jarConnection;
        try
        {
            Artifact artifact = artifactFactory.createArtifact( groupId, artifactId, version, null, "jar" );

            URL url = new URL( "jar:file:" + localRepository.getBasedir() + File.separator
                + localRepository.pathOf( artifact ) + "!" + wsdlFileString );

            jarConnection = (JarURLConnection) url.openConnection();

            entry = jarConnection.getJarEntry();
            if ( entry == null )
            {
                throw new AxisPluginException( "unable to find " + wsdlFileString
                    + " in artifact of sourceDependency " + sourceDependencyString + "." );
            }
        }
        catch ( Exception e )
        {
            throw new AxisPluginException( "unable to open JAR URL connection for extraction of "
                + "WSDL file from artifact of sourceDependency " + sourceDependencyString + ". Reason: "
                + e.getClass().getName() + ": " + e.getMessage(), e );
        }

        File localWsdl = new File( sourceDependencyDirectory, createSafeFileName( sourceDependencyString ) );

// Compare modification timestamp of the jar entry against
// that of the local copy
        if ( localWsdl.exists() && entry.getTime() == localWsdl.lastModified() )
        {
            getLog().debug( "local copy of WSDL file from artifact of sourceDependency " + sourceDependencyString
                + " is up to date." );
            return;
        }

        // The local copy does not exist or it is outdated.
        // Copy the file from the JAR entry to disk.

        if ( !sourceDependencyDirectory.exists() )
        {
            sourceDependencyDirectory.mkdirs();
        }

        InputStream jarWsdlInput = null;
        FileOutputStream localWsdlOutput = null;
        try
        {
            jarWsdlInput = jarConnection.getInputStream();
            localWsdlOutput = new FileOutputStream( localWsdl );

            IOUtil.copy( jarWsdlInput, localWsdlOutput );
            localWsdlOutput.flush();

            getLog().info( "extracted WSDL from sourceDependency " + sourceDependencyString + " ("
                + localWsdl.length() + " Bytes)." );
        }
        catch ( Exception e )
        {
            throw new AxisPluginException( "unable to retrieve " + wsdlFileString
                + " from artifact of sourceDependency " + sourceDependencyString + ".", e );
        }
        finally
        {
            IOUtil.close( jarWsdlInput );
            IOUtil.close( localWsdlOutput );
        }

        localWsdl.setLastModified( entry.getTime() );
    }

    /**
     * move the generated test cases to a suitable location for being picked up by the testing phase
     */
    private void migrateTestSource()
        throws AxisPluginException
    {
        if ( !testSourceDirectory.exists() )
        {
            testSourceDirectory.mkdirs();
        }

        Set testSources = locateTestSources();

        for ( Iterator iter = testSources.iterator(); iter.hasNext(); )
        {
            File source = (File) iter.next();

            try
            {
                FileUtils.copyFileToDirectory( source, getDestinationDirectory( source ) );
                FileUtils.fileDelete( source.getAbsolutePath() );
            }
            catch ( IOException ioe )
            {
                throw new AxisPluginException( "error copying test sources", ioe );
            }
        }

        project.addTestCompileSourceRoot( testSourceDirectory.getPath() );
    }

    /**
     * Try to find out which directory the given generated test source file
     * should be copied to. Calculate this based on the file's relative path to
     * the output directory. If there is no package for the file, the
     * packageSpace configuration is consulted.
     *
     * @param source A generated test source file
     * @return The directory to which the generated test source file should be copied
     */
    private File getDestinationDirectory( File source )
    {
        String relativeFilePath = PathTool.getRelativeFilePath( outputDirectory.getAbsolutePath(),
                                                                source.getAbsolutePath() );
        String relativePath = FileUtils.getPath( relativeFilePath );
        if ( StringUtils.isEmpty( relativePath ) && packageSpace != null )
        {
            relativePath = StringUtils.replace( packageSpace, '.', File.separatorChar );
        }
        return new File( testSourceDirectory, relativePath );
    }

    /**
     * generate the parameter String[] to be passed into the main method
     *
     * @param wsdl path of the wsdl file to process
     * @return argument array for the invocation of {@link org.codehaus.mojo.axistools.WSDL2JavaMojo}
     */
    private String[] generateWSDLArgumentList( File wsdl )
        throws AxisPluginException
    {
        ArrayList argsList = new ArrayList();

        if ( debug )
        {
            argsList.add( "--Debug" );
        }

        if ( verbose )
        {
            argsList.add( "-v" );
        }

        argsList.add( "-o" );
        argsList.add( outputDirectory.getAbsolutePath() );

        if ( serverSide )
        {
            argsList.add( "-s" );
        }

        if ( testCases )
        {
            argsList.add( "-t" );
        }

        if ( allElements )
        {
            argsList.add( "-a" );
        }

        if ( noImports )
        {
            argsList.add( "-n" );
        }

        if ( timeout != null )
        {
            argsList.add( "-O" );
            argsList.add( timeout.toString() );
        }

        if ( noWrapped )
        {
            argsList.add( "-W" );
        }

        if ( wrapArrays )
        {
            argsList.add( "-w" );
        }

        if ( skeletonDeploy )
        {
            argsList.add( "-S" );
            argsList.add( "true" );
        }

        if ( mappings != null && mappings.size() > 0 )
        {
            if ( packageSpace == null )
            {
                Iterator iter = mappings.iterator();
                while ( iter.hasNext() )
                {
                    Mapping mapping = (Mapping) iter.next();
                    argsList.add( "-N" + mapping.getNamespace() + "=" + mapping.getTargetPackage() );
                }
            }
            else
            {
                throw new AxisPluginException( "mappings and packageSpace can not be used together" );
            }
        }

        if ( fileNamespaceToPackage != null )
        {
            argsList.add( "-f" );
            argsList.add( fileNamespaceToPackage.getAbsolutePath() );
        }

        if ( deployScope != null )
        {
            argsList.add( "-d" );
            argsList.add( deployScope );
        }

        if ( typeMappingVersion != null )
        {
            if ( "1.1".equals( typeMappingVersion ) || "1.2".equals( typeMappingVersion ) )
            {
                argsList.add( "-T" );
                argsList.add( typeMappingVersion );
            }
            else
            {
                throw new AxisPluginException( "invalid typeMappingVersion (1.1 or 1.2)" );
            }
        }

        if ( factory != null )
        {
            argsList.add( "-F" );
            argsList.add( factory );
        }

        if ( nsIncludes != null )
        {
           for ( Iterator i = nsIncludes.iterator(); i.hasNext(); )
           {
            argsList.add( "-i" );
            argsList.add( i.next() );
           }
        }

        if ( nsExcludes != null )
        {
           for ( Iterator i = nsExcludes.iterator(); i.hasNext(); )
           {
            argsList.add( "-x" );
            argsList.add( i.next() );
           }
        }

        if ( helperGen )
        {
            argsList.add( "-H" );
        }

        if ( username != null )
        {
            argsList.add( "-U" );
            argsList.add( username );
        }

        if ( password != null )
        {
            argsList.add( "-P" );
            argsList.add( password );
        }

        if ( implementationClassName != null )
        {
            argsList.add( "-c" );
            argsList.add( implementationClassName );
        }

        if ( packageSpace != null && !subPackageByFileName )
        {
            argsList.add( "-p" );
            argsList.add( packageSpace );
        }
        else if ( packageSpace != null && subPackageByFileName )
        {
            argsList.add( "-p" );
            argsList.add( packageSpace + "." + FileUtils.basename( wsdl.getAbsolutePath(), ".wsdl" ) );
        }

        argsList.add( wsdl.toURI().toString() );

        getLog().debug( "argslist: " + argsList.toString() );

        return (String[]) argsList.toArray( new String[argsList.size()] );
    }

    /**
     * scans for the test cases that might have been generated by the call to wsdl2java
     *
     * @return Set of test case File objects
     */
    private Set locateTestSources()
        throws AxisPluginException
    {
        SuffixMapping mapping = new SuffixMapping( "TestCase.java", "TestCase.class" );

        SourceInclusionScanner scanner = new StaleSourceScanner();

        scanner.addSourceMapping( mapping );

        Set testSources = new HashSet();

        try
        {
            testSources.addAll( scanner.getIncludedSources( outputDirectory, testSourceDirectory ) );
        }
        catch ( InclusionScanException e )
        {
            throw new AxisPluginException(
                "Error scanning source root: \'" + outputDirectory + "\' for stale wsdls to reprocess.", e );
        }

        return testSources;
    }

    private Set computeStaleWSDLs()
        throws AxisPluginException
    {
        SuffixMapping mapping = new SuffixMapping( ".wsdl", ".wsdl" );

        SourceInclusionScanner scanner = new StaleSourceScanner( staleMillis );

        scanner.addSourceMapping( mapping );

        Set staleSources = new HashSet();

        try
        {
            if ( ( sourceDirectory != null ) && sourceDirectory.exists() )
            {
                staleSources.addAll( scanner.getIncludedSources( sourceDirectory, timestampDirectory ) );
            }

            if ( ( urlDownloadDirectory != null ) && urlDownloadDirectory.exists() )
            {
                staleSources.addAll( scanner.getIncludedSources( urlDownloadDirectory, timestampDirectory ) );
            }

            if ( ( sourceDependencyDirectory != null ) && sourceDependencyDirectory.exists() )
            {
                staleSources.addAll( scanner.getIncludedSources( sourceDependencyDirectory, timestampDirectory ) );
            }
        }
        catch ( InclusionScanException e )
        {
            throw new AxisPluginException(
                "Error scanning source root: \'" + sourceDirectory + "\' for stale wsdls to reprocess.", e );
        }

        return staleSources;
    }

    private void runEmitter( File wsdl )
        throws AxisPluginException
    {
        Emitter emitter = new Emitter();
        if ( mappings != null )
        {
            getLog().debug( "mappings size : " + mappings.size() );
            HashMap mappingMap = this.getNamespaceMap( mappings );
            getLog().debug( "mappingMap size : " + mappingMap.size() );
            emitter.setNamespaceMap( mappingMap );
        }

        URL wsdlUrl;

        try
        {
            wsdlUrl = wsdl.toURL();
        }
        catch ( MalformedURLException e )
        {
            throw new AxisPluginException( "error processing " + wsdl.getAbsolutePath(), e );
        }

        getLog().debug( "wsdlUrl.toExternalForm() " + wsdlUrl.toExternalForm() );

//emitter.setAllowInvalidURL(mojo.is)
        emitter.setAllWanted( allElements );
// not exists in the mojo
//emitter.setBuildFileWanted(true);
        emitter.setDebug( debug );
// not in the mojo
//emitter.setDefaultTypeMapping(mojo.gett)
//emitter.setDeploy(mojo.is)
        if ( StringUtils.isNotEmpty( factory ) )
        {
            emitter.setFactory( factory );
        }
        emitter.setHelperWanted( helperGen );

        if ( StringUtils.isNotEmpty( implementationClassName ) )
        {
            emitter.setImplementationClassName( implementationClassName );
        }

        // ?? is it correct ?
        emitter.setImports( !noImports );

        // TODO:  is it comma separated in the mojo -> no documentation provided
        emitter.setNamespaceExcludes( nsExcludes == null ? java.util.Collections.EMPTY_LIST : nsExcludes );

        // TODO:  is it comma separated in the mojo -> no documentation provided
        emitter.setNamespaceIncludes( nsIncludes == null ? java.util.Collections.EMPTY_LIST : nsIncludes );

        emitter.setNowrap( noWrapped );

        if ( StringUtils.isNotEmpty( namespaceToPackage ) )
        {
            emitter.setNStoPkg( namespaceToPackage );
        }
        emitter.setOutputDir( outputDirectory.getPath() );
        // TODO: is it the right mojo parameter certainly yes ;-)
        if ( StringUtils.isNotEmpty( packageSpace ) )
        {
            emitter.setPackageName( packageSpace );
        }
        emitter.setPassword( password );
// not in the mojo properties for custom JavaGeneratorFactories
//emitter.setProperties(mojo.getp)
// not in the mojo but needed ??
//emitter.setQName2ClassMap();
//emitter.setQuiet(mojo.is)
//emitter.setScope(mojo.get)
        emitter.setServerSide( serverSide );
// not in the mojo but needed ??
//emitter.setServiceDesc(mojo.gets)
        emitter.setSkeletonWanted( skeletonDeploy );
        emitter.setTestCaseWanted( testCases );

// not in the mojo but needed ?
//emitter.setTypeCollisionProtection(mojo.is)
        emitter.setTypeMappingVersion( typeMappingVersion );
        emitter.setUsername( username );
        emitter.setVerbose( verbose );
        // not in the mojo but needed ?
        emitter.setWrapArrays( wrapArrays );
        try
        {
            emitter.run( wsdlUrl.toExternalForm() );
        }
        catch ( Exception e )
        {
            throw new AxisPluginException( "error running " + wsdlUrl.toExternalForm(), e );
        }
    }

    protected HashMap getNamespaceMap( List mappings )
    {
        HashMap namespaceMap = new HashMap( mappings.size() );
        for ( int i = 0, size = mappings.size(); i < size; i++ )
        {
            Mapping mapping = (Mapping) mappings.get( i );
            getLog().debug( "mapping " + mappings.toString() );
            namespaceMap.put( mapping.getNamespace(), mapping.getTargetPackage() );
        }
        return namespaceMap;

    }

    public void setUrls( ArrayList urls )
    {
        this.urls = urls;
    }

    public void setWsdlFiles( ArrayList wsdlFiles )
    {
        this.wsdlFiles = wsdlFiles;
    }

    public void setSourceDependencies( ArrayList sourceDependencies )
    {
        this.sourceDependencies = sourceDependencies;
    }

    public void setUrlDownloadDirectory( File urlDownloadDirectory )
    {
        this.urlDownloadDirectory = urlDownloadDirectory;
    }

    public void setSourceDependencyDirectory( File sourceDependencyDirectory )
    {
        this.sourceDependencyDirectory = sourceDependencyDirectory;
    }

    public void setUseEmitter( boolean useEmitter )
    {
        this.useEmitter = useEmitter;
    }

    public void setMappings( ArrayList mappings )
    {
        this.mappings = mappings;
    }

    public void setServerSide( boolean serverSide )
    {
        this.serverSide = serverSide;
    }

    public void setPackageSpace( String packageSpace )
    {
        this.packageSpace = packageSpace;
    }

    public void setVerbose( boolean verbose )
    {
        this.verbose = verbose;
    }

    public void setTestCases( boolean testCases )
    {
        this.testCases = testCases;
    }

    public void setRunTestCasesAsUnitTests( boolean runTestCasesAsUnitTests )
    {
        this.runTestCasesAsUnitTests = runTestCasesAsUnitTests;
    }

    public void setAllElements( boolean allElements )
    {
        this.allElements = allElements;
    }

    public void setDebug( boolean debug )
    {
        this.debug = debug;
    }

    public void setTimeout( Integer timeout )
    {
        this.timeout = timeout;
    }

    public void setNoImports( boolean noImports )
    {
        this.noImports = noImports;
    }

    public void setNoWrapped( boolean noWrapped )
    {
        this.noWrapped = noWrapped;
    }

    public void setWrapArrays( boolean wrapArrays )
    {
        this.wrapArrays = wrapArrays;
    }

    public void setSkeletonDeploy( boolean skeletonDeploy )
    {
        this.skeletonDeploy = skeletonDeploy;
    }

    public void setNamespaceToPackage( String namespaceToPackage )
    {
        this.namespaceToPackage = namespaceToPackage;
    }

    public void setFileNamespaceToPackage( File fileNamespaceToPackage )
    {
        this.fileNamespaceToPackage = fileNamespaceToPackage;
    }

    public void setDeployScope( String deployScope )
    {
        this.deployScope = deployScope;
    }

    public void setTypeMappingVersion( String typeMappingVersion )
    {
        this.typeMappingVersion = typeMappingVersion;
    }

    public void setFactory( String factory )
    {
        this.factory = factory;
    }

    public void setNsIncludes( ArrayList nsIncludes )
    {
        this.nsIncludes = nsIncludes;
    }

    public void setNsExcludes( ArrayList nsExcludes )
    {
        this.nsExcludes = nsExcludes;
    }

    public void setHelperGen( boolean helperGen )
    {
        this.helperGen = helperGen;
    }

    public void setUsername( String username )
    {
        this.username = username;
    }

    public void setPassword( String password )
    {
        this.password = password;
    }

    public void setImplementationClassName( String implementationClassName )
    {
        this.implementationClassName = implementationClassName;
    }

    public void setSubPackageByFileName( boolean subPackageByFileName )
    {
        this.subPackageByFileName = subPackageByFileName;
    }

    public void setTestSourceDirectory( File testSourceDirectory )
    {
        this.testSourceDirectory = testSourceDirectory;
    }
}