Coverage report

  %line %branch
org.apache.commons.net.ftp.FTPFile
93% 
100% 

 1  
 /*
 2  
  * Copyright 2001-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;
 17  
 import java.io.Serializable;
 18  
 import java.util.Calendar;
 19  
 
 20  
 /***
 21  
  * The FTPFile class is used to represent information about files stored
 22  
  * on an FTP server.  Because there is no standard representation for
 23  
  * file information on FTP servers, it may not always be possible to
 24  
  * extract all the information that can be represented by FTPFile, or
 25  
  * it may even be possible to extract more information.  In cases where
 26  
  * more information can be extracted, you will want to subclass FTPFile
 27  
  * and implement your own {@link org.apache.commons.net.ftp.FTPFileListParser}
 28  
  *  to extract the information.
 29  
  * However, most FTP servers return file information in a format that
 30  
  * can be completely parsed by
 31  
  * {@link org.apache.commons.net.ftp.DefaultFTPFileListParser}
 32  
  *  and stored in FTPFile.
 33  
  * <p>
 34  
  * <p>
 35  
  * @author Daniel F. Savarese
 36  
  * @see FTPFileListParser
 37  
  * @see DefaultFTPFileListParser
 38  
  * @see FTPClient#listFiles
 39  
  ***/
 40  
 
 41  
 public class FTPFile implements Serializable
 42  
 {
 43  
     /** A constant indicating an FTPFile is a file. ***/
 44  
     public static final int FILE_TYPE = 0;
 45  
     /** A constant indicating an FTPFile is a directory. ***/
 46  
     public static final int DIRECTORY_TYPE = 1;
 47  
     /** A constant indicating an FTPFile is a symbolic link. ***/
 48  
     public static final int SYMBOLIC_LINK_TYPE = 2;
 49  
     /** A constant indicating an FTPFile is of unknown type. ***/
 50  
     public static final int UNKNOWN_TYPE = 3;
 51  
 
 52  
     /** A constant indicating user access permissions. ***/
 53  
     public static final int USER_ACCESS = 0;
 54  
     /** A constant indicating group access permissions. ***/
 55  
     public static final int GROUP_ACCESS = 1;
 56  
     /** A constant indicating world access permissions. ***/
 57  
     public static final int WORLD_ACCESS = 2;
 58  
 
 59  
     /** A constant indicating file/directory read permission. ***/
 60  
     public static final int READ_PERMISSION = 0;
 61  
     /** A constant indicating file/directory write permission. ***/
 62  
     public static final int WRITE_PERMISSION = 1;
 63  
     /**
 64  
      * A constant indicating file execute permission or directory listing
 65  
      * permission.
 66  
      ***/
 67  
     public static final int EXECUTE_PERMISSION = 2;
 68  
 
 69  
     int _type, _hardLinkCount;
 70  
     long _size;
 71  
     String _rawListing, _user, _group, _name, _link;
 72  
     Calendar _date;
 73  
     boolean[] _permissions[];
 74  
 
 75  
     /*** Creates an empty FTPFile. ***/
 76  
     public FTPFile()
 77  238
     {
 78  238
         _permissions = new boolean[3][3];
 79  238
         _rawListing = null;
 80  238
         _type = UNKNOWN_TYPE;
 81  238
         _hardLinkCount = 0;
 82  238
         _size = 0;
 83  238
         _user = null;
 84  238
         _group = null;
 85  238
         _date = null;
 86  238
         _name = null;
 87  238
     }
 88  
 
 89  
 
 90  
     /***
 91  
      * Set the original FTP server raw listing from which the FTPFile was
 92  
      * created.
 93  
      * <p>
 94  
      * @param rawListing  The raw FTP server listing.
 95  
      ***/
 96  
     public void setRawListing(String rawListing)
 97  
     {
 98  202
         _rawListing = rawListing;
 99  202
     }
 100  
 
 101  
     /***
 102  
      * Get the original FTP server raw listing used to initialize the FTPFile.
 103  
      * <p>
 104  
      * @return The original FTP server raw listing used to initialize the
 105  
      *         FTPFile.
 106  
      ***/
 107  
     public String getRawListing()
 108  
     {
 109  0
         return _rawListing;
 110  
     }
 111  
 
 112  
 
 113  
     /***
 114  
      * Determine if the file is a directory.
 115  
      * <p>
 116  
      * @return True if the file is of type <code>DIRECTORY_TYPE</code>, false if
 117  
      *         not.
 118  
      ***/
 119  
     public boolean isDirectory()
 120  
     {
 121  9
         return (_type == DIRECTORY_TYPE);
 122  
     }
 123  
 
 124  
     /***
 125  
      * Determine if the file is a regular file.
 126  
      * <p>
 127  
      * @return True if the file is of type <code>FILE_TYPE</code>, false if
 128  
      *         not.
 129  
      ***/
 130  
     public boolean isFile()
 131  
     {
 132  10
         return (_type == FILE_TYPE);
 133  
     }
 134  
 
 135  
     /***
 136  
      * Determine if the file is a symbolic link.
 137  
      * <p>
 138  
      * @return True if the file is of type <code>UNKNOWN_TYPE</code>, false if
 139  
      *         not.
 140  
      ***/
 141  
     public boolean isSymbolicLink()
 142  
     {
 143  1
         return (_type == SYMBOLIC_LINK_TYPE);
 144  
     }
 145  
 
 146  
     /***
 147  
      * Determine if the type of the file is unknown.
 148  
      * <p>
 149  
      * @return True if the file is of type <code>UNKNOWN_TYPE</code>, false if
 150  
      *         not.
 151  
      ***/
 152  
     public boolean isUnknown()
 153  
     {
 154  0
         return (_type == UNKNOWN_TYPE);
 155  
     }
 156  
 
 157  
 
 158  
     /***
 159  
      * Set the type of the file (<code>DIRECTORY_TYPE</code>,
 160  
      * <code>FILE_TYPE</code>, etc.).
 161  
      * <p>
 162  
      * @param type  The integer code representing the type of the file.
 163  
      ***/
 164  
     public void setType(int type)
 165  
     {
 166  146
         _type = type;
 167  146
     }
 168  
 
 169  
 
 170  
     /***
 171  
      * Return the type of the file (one of the <code>_TYPE</code> constants),
 172  
      * e.g., if it is a directory, a regular file, or a symbolic link.
 173  
      * <p>
 174  
      * @return The type of the file.
 175  
      ***/
 176  
     public int getType()
 177  
     {
 178  37
         return _type;
 179  
     }
 180  
 
 181  
 
 182  
     /***
 183  
      * Set the name of the file.
 184  
      * <p>
 185  
      * @param name  The name of the file.
 186  
      ***/
 187  
     public void setName(String name)
 188  
     {
 189  146
         _name = name;
 190  146
     }
 191  
 
 192  
     /***
 193  
      * Return the name of the file.
 194  
      * <p>
 195  
      * @return The name of the file.
 196  
      ***/
 197  
     public String getName()
 198  
     {
 199  43
         return _name;
 200  
     }
 201  
 
 202  
 
 203  
     /**
 204  
      * Set the file size in bytes.
 205  
      * @param size The file size in bytes.
 206  
      */
 207  
     public void setSize(long size)
 208  
     {
 209  132
         _size = size;
 210  132
     }
 211  
 
 212  
 
 213  
     /***
 214  
      * Return the file size in bytes.
 215  
      * <p>
 216  
      * @return The file size in bytes.
 217  
      ***/
 218  
     public long getSize()
 219  
     {
 220  17
         return _size;
 221  
     }
 222  
 
 223  
 
 224  
     /***
 225  
      * Set the number of hard links to this file.  This is not to be
 226  
      * confused with symbolic links.
 227  
      * <p>
 228  
      * @param links  The number of hard links to this file.
 229  
      ***/
 230  
     public void setHardLinkCount(int links)
 231  
     {
 232  42
         _hardLinkCount = links;
 233  42
     }
 234  
 
 235  
 
 236  
     /***
 237  
      * Return the number of hard links to this file.  This is not to be
 238  
      * confused with symbolic links.
 239  
      * <p>
 240  
      * @return The number of hard links to this file.
 241  
      ***/
 242  
     public int getHardLinkCount()
 243  
     {
 244  6
         return _hardLinkCount;
 245  
     }
 246  
 
 247  
 
 248  
     /***
 249  
      * Set the name of the group owning the file.  This may be
 250  
      * a string representation of the group number.
 251  
      * <p>
 252  
      * @param group The name of the group owning the file.
 253  
      ***/
 254  
     public void setGroup(String group)
 255  
     {
 256  78
         _group = group;
 257  78
     }
 258  
 
 259  
 
 260  
     /***
 261  
      * Returns the name of the group owning the file.  Sometimes this will be
 262  
      * a string representation of the group number.
 263  
      * <p>
 264  
      * @return The name of the group owning the file.
 265  
      ***/
 266  
     public String getGroup()
 267  
     {
 268  9
         return _group;
 269  
     }
 270  
 
 271  
 
 272  
     /***
 273  
      * Set the name of the user owning the file.  This may be
 274  
      * a string representation of the user number;
 275  
      * <p>
 276  
      * @param user The name of the user owning the file.
 277  
      ***/
 278  
     public void setUser(String user)
 279  
     {
 280  91
         _user = user;
 281  91
     }
 282  
 
 283  
     /***
 284  
      * Returns the name of the user owning the file.  Sometimes this will be
 285  
      * a string representation of the user number.
 286  
      * <p>
 287  
      * @return The name of the user owning the file.
 288  
      ***/
 289  
     public String getUser()
 290  
     {
 291  11
         return _user;
 292  
     }
 293  
 
 294  
 
 295  
     /***
 296  
      * If the FTPFile is a symbolic link, use this method to set the name of the
 297  
      * file being pointed to by the symbolic link.
 298  
      * <p>
 299  
      * @param link  The file pointed to by the symbolic link.
 300  
      ***/
 301  
     public void setLink(String link)
 302  
     {
 303  2
         _link = link;
 304  2
     }
 305  
 
 306  
 
 307  
     /***
 308  
      * If the FTPFile is a symbolic link, this method returns the name of the
 309  
      * file being pointed to by the symbolic link.  Otherwise it returns null.
 310  
      * <p>
 311  
      * @return The file pointed to by the symbolic link (null if the FTPFile
 312  
      *         is not a symbolic link).
 313  
      ***/
 314  
     public String getLink()
 315  
     {
 316  29
         return _link;
 317  
     }
 318  
 
 319  
 
 320  
     /***
 321  
      * Set the file timestamp.  This usually the last modification time.
 322  
      * The parameter is not cloned, so do not alter its value after calling
 323  
      * this method.
 324  
      * <p>
 325  
      * @param date A Calendar instance representing the file timestamp.
 326  
      ***/
 327  
     public void setTimestamp(Calendar date)
 328  
     {
 329  132
         _date = date;
 330  132
     }
 331  
 
 332  
 
 333  
     /***
 334  
      * Returns the file timestamp.  This usually the last modification time.
 335  
      * <p>
 336  
      * @return A Calendar instance representing the file timestamp.
 337  
      ***/
 338  
     public Calendar getTimestamp()
 339  
     {
 340  19
         return _date;
 341  
     }
 342  
 
 343  
 
 344  
     /***
 345  
      * Set if the given access group (one of the <code> _ACCESS </code>
 346  
      * constants) has the given access permission (one of the
 347  
      * <code> _PERMISSION </code> constants) to the file.
 348  
      * <p>
 349  
      * @param access The access group (one of the <code> _ACCESS </code>
 350  
      *               constants)
 351  
      * @param permission The access permission (one of the
 352  
      *               <code> _PERMISSION </code> constants)
 353  
      * @param value  True if permission is allowed, false if not.
 354  
      ***/
 355  
     public void setPermission(int access, class="keyword">int permission, boolean value)
 356  
     {
 357  396
         _permissions[access][permission] = value;
 358  396
     }
 359  
 
 360  
 
 361  
     /***
 362  
      * Determines if the given access group (one of the <code> _ACCESS </code>
 363  
      * constants) has the given access permission (one of the
 364  
      * <code> _PERMISSION </code> constants) to the file.
 365  
      * <p>
 366  
      * @param access The access group (one of the <code> _ACCESS </code>
 367  
      *               constants)
 368  
      * @param permission The access permission (one of the
 369  
      *               <code> _PERMISSION </code> constants)
 370  
      ***/
 371  
     public boolean hasPermission(int access, class="keyword">int permission)
 372  
     {
 373  333
         return _permissions[access][permission];
 374  
     }
 375  
 
 376  
 
 377  
     /***
 378  
      * Returns a string representation of the FTPFile information.  This
 379  
      * will be the raw FTP server listing that was used to initialize the
 380  
      * FTPFile instance.
 381  
      * <p>
 382  
      * @return A string representation of the FTPFile information.
 383  
      ***/
 384  
     public String toString()
 385  
     {
 386  0
         return _rawListing;
 387  
     }
 388  
 
 389  
 }

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