Coverage report

  %line %branch
org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
70% 
94% 

 1   
 /*
 2   
  * Copyright 2004-2005 The Apache Software Foundation
 3   
  *
 4   
  * Licensed under the Apache License, Version 2.0 (the "License");
 5   
  * you may not use this file except in compliance with the License.
 6   
  * You may obtain a copy of the License at
 7   
  *
 8   
  *     http://www.apache.org/licenses/LICENSE-2.0
 9   
  *
 10   
  * Unless required by applicable law or agreed to in writing, software
 11   
  * distributed under the License is distributed on an "AS IS" BASIS,
 12   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13   
  * See the License for the specific language governing permissions and
 14   
  * limitations under the License.
 15   
  */
 16   
 package org.apache.commons.net.ftp.parser;
 17   
 
 18   
 import org.apache.commons.net.ftp.Configurable;
 19   
 import org.apache.commons.net.ftp.FTPClientConfig;
 20   
 import org.apache.commons.net.ftp.FTPFileEntryParser;
 21   
 
 22   
 
 23   
 /**
 24   
  * This is the default implementation of the
 25   
  * FTPFileEntryParserFactory interface.  This is the
 26   
  * implementation that will be used by
 27   
  * org.apache.commons.net.ftp.FTPClient.listFiles()
 28   
  * if no other implementation has been specified.
 29   
  *
 30   
  * @see org.apache.commons.net.ftp.FTPClient#listFiles
 31   
  * @see org.apache.commons.net.ftp.FTPClient#setParserFactory
 32   
  */
 33  4 
 public class DefaultFTPFileEntryParserFactory
 34   
     implements FTPFileEntryParserFactory
 35   
 {
 36  4 
 	private FTPClientConfig config = null;
 37   
 
 38   
 	/**
 39   
      * This default implementation of the FTPFileEntryParserFactory
 40   
      * interface works according to the following logic:
 41   
      * First it attempts to interpret the supplied key as a fully
 42   
      * qualified classname of a class implementing the
 43   
      * FTPFileEntryParser interface.  If that succeeds, a parser
 44   
      * object of this class is instantiated and is returned;
 45   
      * otherwise it attempts to interpret the key as an identirier
 46   
      * commonly used by the FTP SYST command to identify systems.
 47   
      * <p/>
 48   
      * If <code>key</code> is not recognized as a fully qualified
 49   
      * classname known to the system, this method will then attempt
 50   
      * to see whether it <b>contains</b> a string identifying one of
 51   
      * the known parsers.  This comparison is <b>case-insensitive</b>.
 52   
      * The intent here is where possible, to select as keys strings
 53   
      * which are returned by the SYST command on the systems which
 54   
      * the corresponding parser successfully parses.  This enables
 55   
      * this factory to be used in the auto-detection system.
 56   
      * <p/>
 57   
      *
 58   
      * @param key    should be a fully qualified classname corresponding to
 59   
      *               a class implementing the FTPFileEntryParser interface<br/>
 60   
      *               OR<br/>
 61   
      *               a string containing (case-insensitively) one of the
 62   
      *               following keywords:
 63   
      *               <ul>
 64   
      *               <li>{@link FTPClientConfig#SYST_UNIX UNIX}</li>
 65   
      *               <li>{@link FTPClientConfig#SYST_NT WINDOWS}</li>
 66   
      *               <li>{@link FTPClientConfig#SYST_OS2 OS/2}</li>
 67   
      *               <li>{@link FTPClientConfig#SYST_OS400 OS/400}</li>
 68   
      *               <li>{@link FTPClientConfig#SYST_VMS VMS}</li>
 69   
      *               <li>{@link FTPClientConfig#SYST_MVS MVS}</li>
 70   
      *               </ul>
 71   
      * @return the FTPFileEntryParser corresponding to the supplied key.
 72   
      * @throws ParserInitializationException thrown if for any reason the factory cannot resolve
 73   
      *                   the supplied key into an FTPFileEntryParser.
 74   
      * @see FTPFileEntryParser
 75   
      */
 76   
     public FTPFileEntryParser createFileEntryParser(String key)
 77   
     {
 78  26 
         Class parserClass = null;
 79  26 
         FTPFileEntryParser parser = null;
 80   
         try
 81   
         {
 82  26 
             parserClass = Class.forName(key);
 83  4 
             parser = (FTPFileEntryParser) parserClass.newInstance();
 84   
         }
 85  22 
         catch (ClassNotFoundException e)
 86   
         {
 87  22 
             String ukey = null;
 88  22 
             if (null != key)
 89   
             {
 90  22 
                 ukey = key.toUpperCase();
 91   
             }
 92  22 
             if (ukey.indexOf(FTPClientConfig.SYST_UNIX) >= 0)
 93   
             {
 94  10 
                 parser = createUnixFTPEntryParser();
 95   
             }
 96  12 
             else if (ukey.indexOf(FTPClientConfig.SYST_VMS) >= 0)
 97   
             {
 98  2 
                 parser = createVMSVersioningFTPEntryParser();
 99   
             }
 100  10 
             else if (ukey.indexOf(FTPClientConfig.SYST_NT) >= 0)
 101   
             {
 102  2 
                 parser = createNTFTPEntryParser();
 103   
             }
 104  8 
             else if (ukey.indexOf(FTPClientConfig.SYST_OS2) >= 0)
 105   
             {
 106  2 
                 parser = createOS2FTPEntryParser();
 107   
             }
 108  6 
             else if (ukey.indexOf(FTPClientConfig.SYST_OS400) >= 0)
 109   
             {
 110  2 
                 parser = createOS400FTPEntryParser();
 111   
             }
 112  4 
             else if (ukey.indexOf(FTPClientConfig.SYST_MVS) >= 0)
 113   
             {
 114  0 
                 parser = createMVSEntryParser();
 115   
         	}
 116   
             else
 117   
             {
 118  4 
                 throw new ParserInitializationException("Unknown parser type: " + key);
 119   
             }
 120   
         }
 121  2 
         catch (ClassCastException e)
 122   
         {
 123  2 
             throw new ParserInitializationException(parserClass.getName()
 124   
                 + " does not implement the interface "
 125   
                 + "org.apache.commons.net.ftp.FTPFileEntryParser.", e);
 126   
         }
 127  0 
         catch (Throwable e)
 128   
         {
 129  0 
             throw new ParserInitializationException("Error initializing parser", e);
 130  20 
         }
 131   
 
 132  20 
         if (parser instanceof Configurable) {
 133  16 
             ((Configurable)parser).configure(this.config);
 134   
         }
 135  20 
         return parser;
 136   
     }
 137   
 
 138   
     /**
 139   
      * <p>Implementation extracts a key from the supplied
 140   
      * {@link  FTPClientConfig FTPClientConfig}
 141   
      * parameter and creates an object implementing the
 142   
      * interface FTPFileEntryParser and uses the supplied configuration
 143   
      * to configure it.
 144   
      * </p><p>
 145   
      * Note that this method will generally not be called in scenarios
 146   
      * that call for autodetection of parser type but rather, for situations
 147   
      * where the user knows that the server uses a non-default configuration
 148   
      * and knows what that configuration is.
 149   
      * </p>
 150   
      * @param config  A {@link  FTPClientConfig FTPClientConfig}
 151   
      * used to configure the parser created
 152   
      *
 153   
      * @return the @link  FTPFileEntryParser FTPFileEntryParser} so created.
 154   
      * @exception ParserInitializationException
 155   
      *                   Thrown on any exception in instantiation
 156   
      * @since 1.4
 157   
      */
 158   
 	public FTPFileEntryParser createFileEntryParser(FTPClientConfig config)
 159   
 	throws ParserInitializationException
 160   
 	{
 161  0 
 	    this.config = config;
 162  0 
 		String key = config.getServerSystemKey();
 163  0 
 		return createFileEntryParser(key);
 164   
 	}
 165   
 
 166   
 
 167   
     public FTPFileEntryParser createUnixFTPEntryParser()
 168   
     {
 169  10 
         return (FTPFileEntryParser) new UnixFTPEntryParser();
 170   
     }
 171   
 
 172   
     public FTPFileEntryParser createVMSVersioningFTPEntryParser()
 173   
     {
 174  2 
         return (FTPFileEntryParser) new VMSVersioningFTPEntryParser();
 175   
     }
 176   
 
 177   
     public FTPFileEntryParser createNTFTPEntryParser()
 178   
     {
 179  2 
     	if (config != null && FTPClientConfig.SYST_NT.equals(
 180   
     	        config.getServerSystemKey()))
 181   
     	{
 182  0 
             return new NTFTPEntryParser();
 183   
     	} else {
 184  2 
             return new CompositeFileEntryParser(class="keyword">new FTPFileEntryParser[]
 185   
 	   	        {
 186   
 	   	            new NTFTPEntryParser(),
 187   
 	   	            new UnixFTPEntryParser()
 188   
 	   	        });
 189   
     	}
 190   
     }
 191   
 
 192   
      public FTPFileEntryParser createOS2FTPEntryParser()
 193   
     {
 194  2 
         return (FTPFileEntryParser) new OS2FTPEntryParser();
 195   
     }
 196   
 
 197   
     public FTPFileEntryParser createOS400FTPEntryParser()
 198   
     {
 199  2 
     	if (config != null &&
 200   
     	        FTPClientConfig.SYST_OS400.equals(config.getServerSystemKey()))
 201   
     	{
 202  0 
             return new OS400FTPEntryParser();
 203   
     	} else {
 204  2 
 	        return new CompositeFileEntryParser(class="keyword">new FTPFileEntryParser[]
 205   
 	            {
 206   
 	                new OS400FTPEntryParser(),
 207   
 	                new UnixFTPEntryParser()
 208   
 	            });
 209   
     	}
 210   
     }
 211   
 
 212   
     public FTPFileEntryParser createMVSEntryParser()
 213   
     {
 214  0 
         return new MVSFTPEntryParser();
 215   
     }
 216   
 
 217   
 
 218   
 
 219   
 }
 220   
 

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.