Coverage Report - org.mockftpserver.core.command.Command
 
Classes in this File Line Coverage Branch Coverage Complexity
Command
100%
29/29
85%
12/14
1.692
 
 1   
 /*
 2   
  * Copyright 20078 the original author or authors.
 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.mockftpserver.core.command;
 17   
 
 18   
 import org.mockftpserver.core.CommandSyntaxException;
 19   
 import org.mockftpserver.core.util.Assert;
 20   
 
 21   
 import java.util.Arrays;
 22   
 import java.util.List;
 23   
 
 24   
 /**
 25   
  * Represents a command received from an FTP client, containing a command name and parameters.
 26   
  * Objects of this class are immutable.
 27   
  *
 28   
  * @author Chris Mair
 29   
  * @version $Revision: 77 $ - $Date: 2008-07-01 22:11:32 -0400 (Tue, 01 Jul 2008) $
 30   
  */
 31   
 public final class Command {
 32   
 
 33   
     private String name;
 34   
     private String[] parameters;
 35   
 
 36   
     /**
 37   
      * Construct a new immutable instance with the specified command name and parameters
 38   
      *
 39   
      * @param name       - the command name; may not be null
 40   
      * @param parameters - the command parameters; may be empty; may not be null
 41   
      */
 42  911 
     public Command(String name, String[] parameters) {
 43  911 
         Assert.notNull(name, "name");
 44  910 
         Assert.notNull(parameters, "parameters");
 45  909 
         this.name = name;
 46  909 
         this.parameters = copy(parameters);
 47  909 
     }
 48   
 
 49   
     /**
 50   
      * Construct a new immutable instance with the specified command name and parameters
 51   
      *
 52   
      * @param name       - the command name; may not be null
 53   
      * @param parameters - the command parameters; may be empty; may not be null
 54   
      */
 55   
     public Command(String name, List parameters) {
 56  402 
         this(name, (String[]) parameters.toArray(new String[parameters.size()]));
 57  402 
     }
 58   
 
 59   
     /**
 60   
      * @return the name
 61   
      */
 62   
     public String getName() {
 63  422 
         return name;
 64   
     }
 65   
 
 66   
     /**
 67   
      * @return the parameters
 68   
      */
 69   
     public String[] getParameters() {
 70  45 
         return copy(parameters);
 71   
     }
 72   
 
 73   
     /**
 74   
      * Get the String value of the parameter at the specified index
 75   
      *
 76   
      * @param index - the index
 77   
      * @return the parameter value as a String
 78   
      * @throws org.mockftpserver.core.util.AssertFailedException
 79   
      *          if the parameter index is invalid or the value is not a valid String
 80   
      */
 81   
     public String getRequiredParameter(int index) {
 82  306 
         assertValidIndex(index);
 83  270 
         return parameters[index];
 84   
     }
 85   
 
 86   
     /**
 87   
      * Get the String value of the parameter at the specified index; return null if no parameter exists for the index
 88   
      *
 89   
      * @param index - the index
 90   
      * @return the parameter value as a String, or null if this Command does not have a parameter for that index
 91   
      */
 92   
     public String getParameter(int index) {
 93  55 
         return (parameters.length > index) ? parameters[index] : null;
 94   
     }
 95   
 
 96   
     /**
 97   
      * Get the String value of the parameter at the specified index; return null if no
 98   
      * parameter exists for the index. This is an alias for {@link #getParameter(int)}.
 99   
      *
 100   
      * @param index - the index
 101   
      * @return the parameter value as a String, or null if this Command does not have a parameter for that index
 102   
      */
 103   
     public String getOptionalString(int index) {
 104  30 
         return getParameter(index);
 105   
     }
 106   
 
 107   
     /**
 108   
      * @see java.lang.Object#equals(java.lang.Object)
 109   
      */
 110   
     public boolean equals(Object obj) {
 111  16 
         if (this == obj) {
 112  9 
             return true;
 113   
         }
 114  7 
         if (obj == null || !(obj instanceof Command)) {
 115  1 
             return false;
 116   
         }
 117  6 
         return this.hashCode() == obj.hashCode();
 118   
     }
 119   
 
 120   
     /**
 121   
      * @see java.lang.Object#hashCode()
 122   
      */
 123   
     public int hashCode() {
 124  12 
         String str = name + Arrays.asList(parameters);
 125  12 
         return str.hashCode();
 126   
     }
 127   
 
 128   
     /**
 129   
      * Return the String representation of this object
 130   
      *
 131   
      * @see java.lang.Object#toString()
 132   
      */
 133   
     public String toString() {
 134  247 
         return "Command[" + name + ":" + Arrays.asList(parameters) + "]";
 135   
     }
 136   
 
 137   
     /**
 138   
      * Return the name, normalized to a common format - convert to upper case.
 139   
      *
 140   
      * @return the name converted to upper case
 141   
      */
 142   
     public static String normalizeName(String name) {
 143  5260 
         return name.toUpperCase();
 144   
     }
 145   
 
 146   
     /**
 147   
      * Construct a shallow copy of the specified array
 148   
      *
 149   
      * @param array - the array to copy
 150   
      * @return a new array with the same contents
 151   
      */
 152   
     private static String[] copy(String[] array) {
 153  954 
         String[] newArray = new String[array.length];
 154  954 
         System.arraycopy(array, 0, newArray, 0, array.length);
 155  954 
         return newArray;
 156   
     }
 157   
 
 158   
     /**
 159   
      * Assert that the index is valid
 160   
      *
 161   
      * @param index - the index
 162   
      * @throws org.mockftpserver.core.CommandSyntaxException
 163   
      *          - if the parameter index is invalid
 164   
      */
 165   
     private void assertValidIndex(int index) {
 166  306 
         if (index < 0 || index >= parameters.length) {
 167  36 
             throw new CommandSyntaxException("The parameter index " + index + " is not valid for " + this);
 168   
         }
 169  270 
     }
 170   
 
 171   
 }
Report generated by Cobertura 1.9.4.1 on 7/17/12 9:22 PM.