WsImportMojo.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2012-2013 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle 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.
 *
 *
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 * Copyright 2006 Guillaume Nodet
 *
 * Licensed 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.
 */

package org.codehaus.mojo.jaxws;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Formatter;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.settings.Proxy;
import org.apache.maven.settings.Settings;

/**
 * 
 * @author gnodet (gnodet@apache.org)
 * @author dantran (dantran@apache.org)
 */
abstract class WsImportMojo
    extends AbstractJaxwsMojo
{

    private static final String STALE_FILE_PREFIX = ".";

    private static final String PATTERN = "[^\\s]+\\.wsdl$";

    /**
     * The package in which the source files will be generated.
     */
    @Parameter
    private String packageName;

    /**
     * Catalog file to resolve external entity references support TR9401, 
     * XCatalog, and OASIS XML Catalog format.
     */
    @Parameter
    private File catalog;

    /**
     * Set HTTP/HTTPS proxy. Format is <code>[user[:password]@]proxyHost[:proxyPort]</code>.
     */
    @Parameter
    private String httpproxy;

    /**
     * Directory containing WSDL files.
     */
    @Parameter( defaultValue = "${project.basedir}/src/wsdl" )
    private File wsdlDirectory;

    /**
     * List of files to use for WSDLs. If not specified, all <code>.wsdl</code>
     * files in the <code>wsdlDirectory</code> will be used.
     */
    @Parameter
    protected List<String> wsdlFiles;

    /**
     * List of external WSDL URLs to be compiled.
     */
    @Parameter
    private List<?> wsdlUrls;

    /**
     * Directory containing binding files.
     */
    @Parameter( defaultValue = "${project.basedir}/src/jaxws" )
    protected File bindingDirectory;

    /**
     * List of files to use for bindings. If not specified, all <code>.xml</code>
     * files in the <code>bindingDirectory</code> will be used.
     */
    @Parameter
    protected List<String> bindingFiles;

    /**
     * &#64;WebService.wsdlLocation and &#64;WebServiceClient.wsdlLocation value.
     * 
     * <p>
     * Can end with asterisk in which case relative path of the WSDL will
     * be appended to the given <code>wsdlLocation</code>.
     * </p>
     *
     * <p>Example:
     * <pre>
     *  ...
     *  &lt;configuration>
     *      &lt;wsdlDirectory>src/mywsdls&lt;/wsdlDirectory>
     *      &lt;wsdlFiles>
     *          &lt;wsdlFile>a.wsdl&lt;/wsdlFile>
     *          &lt;wsdlFile>b/b.wsdl&lt;/wsdlFile>
     *          &lt;wsdlFile>${project.basedir}/src/mywsdls/c.wsdl&lt;/wsdlFile>
     *      &lt;/wsdlFiles>
     *      &lt;wsdlLocation>http://example.com/mywebservices/*&lt;/wsdlLocation>
     *  &lt;/configuration>
     *  ...
     * </pre>
     * wsdlLocation for <code>a.wsdl</code> will be http://example.com/mywebservices/a.wsdl<br/>
     * wsdlLocation for <code>b/b.wsdl</code> will be http://example.com/mywebservices/b/b.wsdl<br/>
     * wsdlLocation for <code>${project.basedir}/src/mywsdls/c.wsdl</code> will be file://absolute/path/to/c.wsdl
     * </p>
     *
     * <p>
     * Note: External binding files cannot be used if asterisk notation is in place.
     * </p>
     */
    @Parameter
    private String wsdlLocation;

    /**
     * Generate code as per the given JAXWS specification version.
     * Setting "2.0" will cause JAX-WS to generate artifacts
     * that run with JAX-WS 2.0 runtime.
     */
    @Parameter
    private String target;

    /**
     * Suppress wsimport output.
     */
    @Parameter( defaultValue = "false" )
    private boolean quiet;

    /**
     * Local portion of service name for generated JWS implementation.
     * Implies <code>genJWS=true</code>.
     *
     * Note: It is a QName string, formatted as: "{" + Namespace URI + "}" + local part
     */
    @Parameter
    private String implServiceName;

    /**
     * Local portion of port name for generated JWS implementation.
     * Implies <code>genJWS=true</code>.
     *
     * Note: It is a QName string, formatted as: "{" + Namespace URI + "}" + local part
     */
    @Parameter
    private String implPortName;

    /**
     * Generate stubbed JWS implementation file.
     */
    @Parameter( defaultValue = "false" )
    private boolean genJWS;

    /**
     * Turn off compilation after code generation and let generated sources be
     * compiled by maven during compilation phase; keep is turned on with this option.
     */
    @Parameter( defaultValue = "true" )
    private boolean xnocompile;

    /**
     * Maps headers not bound to the request or response messages to Java method parameters.
     */
    @Parameter( defaultValue = "false" )
    private boolean xadditionalHeaders;

    /**
     * Turn on debug message.
     */
    @Parameter( defaultValue = "false" )
    private boolean xdebug;

    /**
     * Binding W3C EndpointReferenceType to Java. By default WsImport follows spec and does not bind
     * EndpointReferenceType to Java and uses the spec provided {@link javax.xml.ws.wsaddressing.W3CEndpointReference}
     */
    @Parameter( defaultValue = "false" )
    private boolean xnoAddressingDataBinding;

    /**
     * Specify the location of authorization file.
     */
    @Parameter
    protected File xauthFile;

    /**
     * Disable the SSL Hostname verification while fetching WSDL(s).
     */
    @Parameter( defaultValue = "false" )
    private boolean xdisableSSLHostnameVerification;

    /**
     * If set, the generated Service classes will load the WSDL file from a URL generated from the base resource.
     */
    @Parameter( defaultValue = "false" )
    private boolean xuseBaseResourceAndURLToLoadWSDL;

    /**
     * Disable Authenticator used by JAX-WS RI, <code>xauthfile</code> will be ignored if set.
     */
    @Parameter( defaultValue = "false" )
    private boolean xdisableAuthenticator;

    /**
     * Specify optional XJC-specific parameters that should simply be passed to <code>xjc</code>
     * using <code>-B</code> option of WsImport command.
     * <p>
     * Multiple elements can be specified, and each token must be placed in its own list.
     * </p>
     */
    @Parameter
    private List<String> xjcArgs;

    /**
     * The folder containing flag files used to determine if the output is stale.
     */
    @Parameter( defaultValue = "${project.build.directory}/jaxws/stale" )
    private File staleFile;

    /**
     */
    @Parameter( defaultValue = "${settings}", readonly = true, required = true )
    private Settings settings;

    protected abstract File getImplDestDir();

    /**
     * Returns the dependencies that should be placed on the classpath for the classloader
     * to lookup wsdl files.
     */
    protected abstract List<String> getWSDLFileLookupClasspathElements();

    @Override
    public void executeJaxws()
        throws MojoExecutionException
    {
        try
        {
            URL[] wsdls = getWSDLFiles();
            if ( wsdls.length == 0 && ( wsdlUrls == null || wsdlUrls.isEmpty() ) )
            {
                getLog().info( "No WSDLs are found to process, Specify at least one of the following parameters: "
                        + "wsdlFiles, wsdlDirectory or wsdlUrls." );
                return;
            }
            this.processWsdlViaUrls();
            this.processLocalWsdlFiles( wsdls );
        }
        catch ( MojoExecutionException e )
        {
            throw e;
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( e.getMessage(), e );
        }
    }

    @Override
    protected String getMain()
    {
        return "com.sun.tools.ws.wscompile.WsimportTool";
    }

    @Override
    protected String getToolName()
    {
        return "wsimport";
    }

    @Override
    protected boolean isXnocompile()
    {
        return xnocompile;
    }

    private void processLocalWsdlFiles( URL[] wsdls )
        throws MojoExecutionException, IOException
    {
        for ( URL u : wsdls )
        {
            String url = u.toExternalForm();
            if ( isOutputStale( url ) )
            {
                getLog().info( "Processing: " + url );
                String relPath = null;
                if ( "file".equals( u.getProtocol() ) )
                {
                    relPath = getRelativePath( new File( u.getPath() ) );
                }
                ArrayList<String> args = getWsImportArgs( relPath );
                args.add( "\"" + url + "\"" );
                getLog().info( "jaxws:wsimport args: " + args );
                exec( args );
                touchStaleFile( url );
            }
            else
            {
                getLog().info( "Ignoring: " + url );
            }
            addSourceRoot( getSourceDestDir().getAbsolutePath() );
        }
    }

    /**
     * Process external wsdl
     */
    private void processWsdlViaUrls()
        throws MojoExecutionException, IOException
    {
        for ( int i = 0; wsdlUrls != null && i < wsdlUrls.size(); i++ )
        {
            String wsdlUrl = wsdlUrls.get( i ).toString();
            if ( isOutputStale( wsdlUrl ) )
            {
                getLog().info( "Processing: " + wsdlUrl );
                ArrayList<String> args = getWsImportArgs( null );
                args.add( "\"" + wsdlUrl + "\"" );
                getLog().info( "jaxws:wsimport args: " + args );
                exec( args );
                touchStaleFile( wsdlUrl );
            }
            addSourceRoot( getSourceDestDir().getAbsolutePath() );
        }
    }

    /**
     * Returns wsimport's command arguments as a list
     */
    private ArrayList<String> getWsImportArgs( String relativePath )
        throws MojoExecutionException
    {
        ArrayList<String> args = new ArrayList<>();
        args.addAll( getCommonArgs() );

        if ( httpproxy != null )
        {
            args.add( "-httpproxy:" + httpproxy );
        }
        else if ( settings != null )
        {
            String proxyString = getActiveHttpProxy( settings );
            if ( proxyString != null )
            {
                args.add( "-httpproxy:" + proxyString );
            }

            String nonProxyHostsString = getActiveNonProxyHosts( settings );
            if ( nonProxyHostsString != null )
            {
                addVmArg( "-Dhttp.nonProxyHosts=" + nonProxyHostsString.replace( "|", "^|" ) );
            }
        }

        if ( packageName != null )
        {
            args.add( "-p" );
            args.add( packageName );
        }

        if ( catalog != null )
        {
            args.add( "-catalog" );
            args.add( "'" + catalog.getAbsolutePath() + "'" );
        }

        if ( wsdlLocation != null )
        {
            if ( relativePath != null )
            {
                args.add( "-wsdllocation" );
                args.add( wsdlLocation.replaceAll( "\\*", relativePath ) );
            }
            else if ( !wsdlLocation.contains( "*" ) )
            {
                args.add( "-wsdllocation" );
                args.add( wsdlLocation );
            }
        }

        if ( target != null )
        {
            args.add( "-target" );
            args.add( target );
        }

        if ( quiet )
        {
            args.add( "-quiet" );
        }

        if ( ( genJWS || implServiceName != null || implPortName != null ) && isArgSupported( "-generateJWS" ) )
        {
            args.add( "-generateJWS" );
            if ( implServiceName != null && isArgSupported( "-implServiceName" ) )
            {
                args.add( "-implServiceName" );
                args.add( implServiceName );
            }
            if ( implPortName != null && isArgSupported( "-implPortName" ) )
            {
                args.add( "-implPortName" );
                args.add( implPortName );
            }
            File implDestDir = getImplDestDir();
            if ( !implDestDir.mkdirs() && !implDestDir.exists() )
            {
                getLog().warn( "Cannot create directory: " + implDestDir.getAbsolutePath() );
            }
            args.add( "-implDestDir" );
            args.add( "'" + implDestDir.getAbsolutePath() + "'" );
            if ( !project.getCompileSourceRoots().contains( implDestDir.getAbsolutePath() ) )
            {
                project.addCompileSourceRoot( implDestDir.getAbsolutePath() );
            }
        }

        if ( xdebug )
        {
            args.add( "-Xdebug" );
        }

        if ( xnoAddressingDataBinding )
        {
            args.add( "-Xno-addressing-databinding" );
        }

        if ( xadditionalHeaders )
        {
            args.add( "-XadditionalHeaders" );
        }

        if ( xauthFile != null )
        {
            args.add( "-Xauthfile" );
            args.add( xauthFile.getAbsolutePath() );
        }

        if ( xdisableSSLHostnameVerification )
        {
            args.add( "-XdisableSSLHostnameVerification" );
        }
        if ( xuseBaseResourceAndURLToLoadWSDL )
        {
            args.add( "-XuseBaseResourceAndURLToLoadWSDL" );
        }
        if ( xdisableAuthenticator && isArgSupported( "-XdisableAuthenticator" ) )
        {
            args.add( "-XdisableAuthenticator" );
        }

        if ( xjcArgs != null )
        {
            for ( String xjcArg : xjcArgs )
            {
                if ( xjcArg.startsWith( "-" ) )
                {
                    args.add( "-B" + xjcArg );
                }
                else
                {
                    args.add( xjcArg );
                }
            }
        }

        // Bindings
        File[] bindings = getBindingFiles();
        if ( bindings.length > 0 && wsdlLocation != null && wsdlLocation.contains( "*" ) )
        {
            throw new MojoExecutionException( "External binding file(s) can not be bound to more WSDL files ("
                + wsdlLocation + ")\n" + "Please use either inline binding(s) or multiple execution tags." );
        }
        for ( File binding : bindings )
        {
            args.add( "-b" );
            args.add( "'" + binding.toURI() + "'" );
        }

        return args;
    }

    /**
     * Returns a file array of xml files to translate to object models.
     * 
     * @return An array of schema files to be parsed by the schema compiler.
     */
    public final File[] getBindingFiles()
    {
        File[] bindings;

        if ( bindingFiles != null )
        {
            bindings = new File[bindingFiles.size()];
            for ( int i = 0; i < bindingFiles.size(); ++i )
            {
                String schemaName = bindingFiles.get( i );
                File file = new File( schemaName );
                if ( !file.isAbsolute() )
                {
                    file = new File( bindingDirectory, schemaName );
                }
                bindings[i] = file;
            }
        }
        else
        {
            getLog().debug( "The binding Directory is " + bindingDirectory );
            bindings = bindingDirectory.listFiles( XML_FILE_FILTER );
            if ( bindings == null )
            {
                bindings = new File[0];
            }
        }
        return bindings;
    }

    /**
     * Returns an array of wsdl files to translate to object models.
     * 
     * @return An array of schema files to be parsed by the schema compiler.
     */
    private URL[] getWSDLFiles()
        throws MojoExecutionException
    {
        List<URL> files = new ArrayList<>();

        List<String> classpathElements = getWSDLFileLookupClasspathElements();
        List<URL> urlCpath = new ArrayList<>( classpathElements.size() );
        for ( String el : classpathElements )
        {
            try
            {
                URL u = new File( el ).toURI().toURL();
                urlCpath.add( u );
            }
            catch ( MalformedURLException e )
            {
                throw new MojoExecutionException( "Error while retrieving list of WSDL files to process", e );
            }
        }
        
        try ( URLClassLoader loader = new URLClassLoader( urlCpath.toArray( new URL[0] ) ) )
        {
            if ( wsdlFiles != null )
            {
                for ( String wsdlFileName : wsdlFiles )
                {
                    File wsdl = new File( wsdlFileName );
                    URL toAdd = null;
                    if ( !wsdl.isAbsolute() )
                    {
                        wsdl = new File( wsdlDirectory, wsdlFileName );
                    }
                    if ( !wsdl.exists() )
                    {
                        toAdd = loader.getResource( wsdlFileName );
                    }
                    else
                    {
                        try
                        {
                            toAdd = wsdl.toURI().toURL();
                        }
                        catch ( MalformedURLException ex )
                        {
                            getLog().error( ex );
                        }
                    }
                    getLog().debug( "The wsdl File is '" + wsdlFileName + "' from '" + toAdd + "'" );
                    if ( toAdd != null )
                    {
                        files.add( toAdd );
                    }
                    else
                    {
                        throw new MojoExecutionException( "'" + wsdlFileName + "' not found." );
                    }
                }
            }
            else
            {
                getLog().debug( "The wsdl Directory is " + wsdlDirectory );
                if ( wsdlDirectory.exists() )
                {
                    File[] wsdls = wsdlDirectory.listFiles( WSDL_FILE_FILTER );
                    for ( File wsdl : wsdls )
                    {
                        files.add( wsdl.toURI().toURL() );
                    }
                }
                else
                {
                    URI rel = project.getBasedir().toURI().relativize( wsdlDirectory.toURI() );
                    String dir = rel.getPath();
                    URL u = loader.getResource( dir );
                    if ( u == null )
                    {
                        dir = "WEB-INF/wsdl/";
                        u = loader.getResource( dir );
                    }
                    if ( u == null )
                    {
                        dir = "META-INF/wsdl/";
                        u = loader.getResource( dir );
                    }
                    if ( !( u == null || !"jar".equalsIgnoreCase( u.getProtocol() ) ) )
                    {
                        String path = u.getPath();
                        Pattern p = Pattern.compile( dir.replace( File.separatorChar, '/' ) + PATTERN,
                                                     Pattern.CASE_INSENSITIVE );
                        try ( JarFile jarFile = new JarFile( path.substring( 5, path.indexOf( "!/" ) ) ) )
                        {
                            Enumeration<JarEntry> jes = jarFile.entries();
                            while ( jes.hasMoreElements() )
                            {
                                JarEntry je = jes.nextElement();
                                Matcher m = p.matcher( je.getName() );
                                if ( m.matches() )
                                {
                                    String s = "jar:" + path.substring( 0, path.indexOf( "!/" ) + 2 ) + je.getName();
                                    files.add( new URL( s ) );
                                }
                            }
                        }
                        catch ( IOException ex )
                        {
                            getLog().error( ex );
                        }
                    }
                }
            }
        }
        catch ( MojoExecutionException e )
        {
            throw e;
        }
        catch ( Exception e )
        {
            throw new MojoExecutionException( "Error while retrieving list of WSDL files to process", e );
        }

        return files.toArray( new URL[0] );
    }

    /**
     * A class used to look up .xml documents from a given directory.
     */
    private static final FileFilter XML_FILE_FILTER = f -> f.getName().endsWith( ".xml" );

    /**
     * A class used to look up .wsdl documents from a given directory.
     */
    private static final FileFilter WSDL_FILE_FILTER = f -> f.getName().endsWith( ".wsdl" );

    private String getRelativePath( File f )
    {
        if ( wsdlFiles != null )
        {
            for ( String s : wsdlFiles )
            {
                String path = f.getPath().replace( File.separatorChar, '/' );
                if ( path.endsWith( s ) && path.length() != s.length() )
                {
                    return s;
                }
            }
        }
        else if ( wsdlDirectory != null && wsdlDirectory.exists() )
        {
            File[] wsdls = wsdlDirectory.listFiles( WSDL_FILE_FILTER );
            for ( File wsdl : wsdls )
            {
                String path = f.getPath().replace( File.separatorChar, '/' );
                if ( path.endsWith( wsdl.getName() ) )
                {
                    return wsdl.getName();
                }
            }
        }
        return null;
    }

    /**
     * Returns true if given WSDL resource or any binding file is newer than the <code>staleFlag</code> file.
     * 
     * @return True if wsdl files have been modified since the last build.
     */
    private boolean isOutputStale( String resource )
    {
        File[] sourceBindings = getBindingFiles();
        File stFile = new File( staleFile, STALE_FILE_PREFIX + getHash( resource ) );
        boolean stale = !stFile.exists();
        if ( !stale )
        {
            getLog().debug( "Stale flag file exists, comparing to wsdls and bindings." );
            long staleMod = stFile.lastModified();

            try
            {
                // resource can be URL
                URL sourceWsdl = new URL( resource );
                if ( sourceWsdl.openConnection().getLastModified() > staleMod )
                {
                    getLog().debug( resource + " is newer than the stale flag file." );
                    stale = true;
                }
            }
            catch ( MalformedURLException mue )
            {
                // or a file
                File sourceWsdl = new File( resource );
                if ( sourceWsdl.lastModified() > staleMod )
                {
                    getLog().debug( resource + " is newer than the stale flag file." );
                    stale = true;
                }
            }
            catch ( IOException ioe )
            {
                // possible error while opening connection
                getLog().error( ioe );
            }

            for ( File sourceBinding : sourceBindings )
            {
                if ( sourceBinding.lastModified() > staleMod )
                {
                    getLog().debug( sourceBinding.getName() + " is newer than the stale flag file." );
                    stale = true;
                }
            }
        }
        return stale;
    }

    private void touchStaleFile( String resource )
        throws IOException
    {
        File stFile = new File( staleFile, STALE_FILE_PREFIX + getHash( resource ) );
        if ( !stFile.exists() )
        {
            File staleDir = stFile.getParentFile();
            if ( !staleDir.mkdirs() && !staleDir.exists() )
            {
                getLog().warn( "Cannot create directory: " + staleDir.getAbsolutePath() );
            }
            if ( !stFile.createNewFile() )
            {
                getLog().warn( "Cannot create file: " + stFile.getAbsolutePath() );
            }
            getLog().debug( "Stale flag file created.[" + stFile.getAbsolutePath() + "]" );
        }
        else
        {
            if ( !stFile.setLastModified( System.currentTimeMillis() ) )
            {
                getLog().warn( "Stale file has not been updated!" );
            }
        }
    }

    private String getHash( String s )
    {
        try ( Formatter formatter = new Formatter() )
        {
            MessageDigest md = MessageDigest.getInstance( "SHA" );
            for ( byte b : md.digest( s.getBytes( "UTF-8" ) ) )
            {
                formatter.format( "%02x", b );
            }
            return formatter.toString();
        }
        catch ( UnsupportedEncodingException ex )
        {
            getLog().debug( ex.getMessage(), ex );
        }
        catch ( NoSuchAlgorithmException ex )
        {
            getLog().debug( ex.getMessage(), ex );
        }

        // fallback to some default
        getLog().warn( "Could not compute hash for " + s + ". Using fallback method." );
        return s.substring( s.lastIndexOf( '/' ) ).replaceAll( "\\.", "-" );
    }

    /**
     * @return proxy string as [user[:password]@]proxyHost[:proxyPort] or null
     */
    static String getActiveHttpProxy( Settings s )
    {
        String retVal = null;
        for ( Proxy p : s.getProxies() )
        {
            if ( p.isActive() && "http".equals( p.getProtocol() ) )
            {
                StringBuilder sb = new StringBuilder();
                String user = p.getUsername();
                String pwd = p.getPassword();
                if ( user != null )
                {
                    sb.append( user );
                    if ( pwd != null )
                    {
                        sb.append( ":" );
                        sb.append( pwd );
                    }
                    sb.append( "@" );
                }
                sb.append( p.getHost() );
                sb.append( ":" );
                sb.append( p.getPort() );
                retVal = sb.toString().trim();
                break;
            }
        }
        return retVal;
    }

    static String getActiveNonProxyHosts( Settings s )
    {
        String retVal = null;
        for ( Proxy p : s.getProxies() )
        {
            if ( p.isActive() && "http".equals( p.getProtocol() ) )
            {
                retVal = p.getNonProxyHosts();
                break;
            }
        }
        return retVal;
    }
}