AbstractFileCommand (Mule File Extension Common 1.3.2 API)

java.lang.Object
- org.mule.extension.file.common.api.command.AbstractFileCommand<F,I>

Type Parameters:

F - the generic type of the FileSystem on which the operation is performed

I - generic type for a class that identifies a file or directory.

Direct Known Subclasses:

ExternalFileCommand, FileCommand
```
public abstract class AbstractFileCommand<F extends FileSystem,I>
extends Object
```
Base class for implementations of the Command design pattern which performs operations on a file system

Since:

1.3.0

Field Summary

Fields
Modifier and Type Field and Description

protected F fileSystem

Fields
Modifier and Type	Field and Description
`protected F`	`fileSystem`

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractFileCommand(F fileSystem)
Creates a new instance

Constructors
Modifier	Constructor and Description
`protected`	`AbstractFileCommand(F fileSystem)` Creates a new instance

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`FileAlreadyExistsException`	`alreadyExistsException(I path)` Returns a `IllegalPathException` explaining that an operation is trying to write to the given `path` but it already exists and no overwrite instruction was provided.
`protected void`	`assureParentFolderExists(I path, boolean createParentFolder)` Method that, given a path, checks if its parent folder exists.
`protected IllegalPathException`	`cannotListFileException(I path)` Returns a `IllegalPathException` explaining that a `FileSystem.list(FileConnectorConfig, String, boolean, Predicate)` operation was attempted on a `path` pointing to a file.
`protected IllegalPathException`	`cannotReadDirectoryException(I path)` Returns an `IllegalPathException` explaining that a `FileSystem.read(FileConnectorConfig, String, boolean)` operation was attempted on a `path` pointing to a directory
`protected abstract void`	`doMkDirs(I directoryPath)` Creates the directory pointed by `directoryPath`.
`RuntimeException`	`exception(String message)` Returns a properly formatted `MuleRuntimeException` for the given `message` and `cause`
`RuntimeException`	`exception(String message, Exception cause)` Returns a properly formatted `MuleRuntimeException` for the given `message` and `cause`
`protected abstract boolean`	`exists(I path)` Returns true if the given `path` exists
`protected abstract I`	`getAbsolutePath(I path)` Returns an object representing the absolute path for the given path.
`protected abstract I`	`getBasePath(FileSystem fileSystem)` Returns a path to which all non absolute paths are relative to
`protected abstract I`	`getParent(I path)` Returns the parent path, or `null` if this path does not have a parent.
`protected boolean`	`isVirtualDirectory(String fileName)`
`protected void`	`mkdirs(I directoryPath)` Creates the directory pointed by `directoryPath` also creating any missing parent directories
`protected IllegalPathException`	`pathNotFoundException(I path)` Returns a `IllegalPathException` explaining that a `FileSystem.list(FileConnectorConfig, String, boolean, Predicate)` operation was attempted on a `path` pointing to a file.
`protected abstract String`	`pathToString(I path)`
`protected I`	`resolveExistingPath(String filePath)` Similar to `resolvePath(String)` only that it throws a `IllegalArgumentException` if the given path doesn't exist.
`protected abstract I`	`resolvePath(I basePath, String filePath)` Resolve the given basePath against the filePath.
`protected I`	`resolvePath(String filePath)` Returns an absolute path for the given `filePath`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - fileSystem
```
protected final F extends FileSystem fileSystem
```
- Constructor Detail
  - AbstractFileCommand
```
protected AbstractFileCommand(F fileSystem)
```
    Creates a new instance
    
    Parameters:
    
    fileSystem - the FileSystem on which the operation is performed
- Method Detail
  - exists
```
protected abstract boolean exists(I path)
```
    Returns true if the given path exists
    
    Parameters:
    
    path - the path to test
    
    Returns:
    
    whether the path exists
  - assureParentFolderExists
```
protected void assureParentFolderExists(I path,
                                        boolean createParentFolder)
```
    Method that, given a path, checks if its parent folder exists. If it exists, this method returns void. Otherwise, this method allows to create such parent by setting the the createParentFolder parameter to true. If it is set to false and the parent folder does not exist, this method throws IllegalPathException.
    
    Parameters:
    
    path - the path to test
    
    createParentFolder - indicates whether to create the parent folder or not.
    
    Throws:
    
    {@link - IllegalPathException} if the parent path does not exists and createParentFolder is set to false.
  - mkdirs
```
protected void mkdirs(I directoryPath)
```
    Creates the directory pointed by directoryPath also creating any missing parent directories
    
    Parameters:
    
    directoryPath - the path to the directory you want to create
  - resolvePath
```
protected I resolvePath(String filePath)
```
    Returns an absolute path for the given filePath
    
    Parameters:
    
    filePath - the relative path to a file or directory
    
    Returns:
    
    an absolute path
  - isVirtualDirectory
```
protected boolean isVirtualDirectory(String fileName)
```
    Parameters:
    
    fileName - the name of a file
    
    Returns:
    
    true if fileName equals to "." or ".."
  - resolveExistingPath
```
protected I resolveExistingPath(String filePath)
```
    Similar to resolvePath(String) only that it throws a IllegalArgumentException if the given path doesn't exist.
    The existence of the obtained path is verified by delegating into #exists(I)
    
    Parameters:
    
    filePath - the path to a file or directory
    
    Returns:
    
    an absolute path
  - cannotReadDirectoryException
```
protected IllegalPathException cannotReadDirectoryException(I path)
```
    Returns an IllegalPathException explaining that a FileSystem.read(FileConnectorConfig, String, boolean) operation was attempted on a path pointing to a directory
    
    Parameters:
    
    path - the path on which a read was attempted
    
    Returns:
    
    IllegalPathException
  - cannotListFileException
```
protected IllegalPathException cannotListFileException(I path)
```
    Returns a IllegalPathException explaining that a FileSystem.list(FileConnectorConfig, String, boolean, Predicate) operation was attempted on a path pointing to a file.
    
    Parameters:
    
    path - the path on which a list was attempted
    
    Returns:
    
    IllegalPathException
  - pathNotFoundException
```
protected IllegalPathException pathNotFoundException(I path)
```
    Returns a IllegalPathException explaining that a FileSystem.list(FileConnectorConfig, String, boolean, Predicate) operation was attempted on a path pointing to a file.
    
    Parameters:
    
    path - the on which a list was attempted
    
    Returns:
    
    RuntimeException
  - alreadyExistsException
```
public FileAlreadyExistsException alreadyExistsException(I path)
```
    Returns a IllegalPathException explaining that an operation is trying to write to the given path but it already exists and no overwrite instruction was provided.
    
    Parameters:
    
    path - the that the operation tried to modify
    
    Returns:
    
    IllegalPathException
  - exception
```
public RuntimeException exception(String message)
```
    Returns a properly formatted MuleRuntimeException for the given message and cause
    
    Parameters:
    
    message - the exception's message
    
    Returns:
    
    a RuntimeException
  - exception
```
public RuntimeException exception(String message,
                                  Exception cause)
```
    Returns a properly formatted MuleRuntimeException for the given message and cause
    
    Parameters:
    
    message - the exception's message
    
    cause - the exception's cause
    
    Returns:
    
    RuntimeException
  - getParent
```
protected abstract I getParent(I path)
```
    Returns the parent path, or null if this path does not have a parent.
    The parent of this path object consists of this path's root component, if any, and each element in the path except for the farthest from the root in the directory hierarchy. This method does not access the file system; the path or its parent may not exist. Furthermore, this method does not eliminate special names such as "." and ".." that may be used in some implementations. On UNIX for example, the parent of "/a/b/c" is "/a/b", and the parent of "x/y/." is "x/y".
    
    Returns:
    
    a path representing the path's parent
  - getBasePath
```
protected abstract I getBasePath(FileSystem fileSystem)
```
    Returns a path to which all non absolute paths are relative to
    
    Parameters:
    
    fileSystem - the file system that we're connecting to
    
    Returns:
    
    a not null base path for the filesystem
  - resolvePath
```
protected abstract I resolvePath(I basePath,
                                 String filePath)
```
    Resolve the given basePath against the filePath.
    If the filePath parameter is an absolute path then this method trivially returns filePath. If filePath is an empty path then this method trivially returns basePath. Otherwise this method considers the basePath to be a directory and resolves the given filePath against the basePath. In the simplest case, the given filePath does not have a root component, in which case this method joins both paths and returns a resulting path that ends with the given filePath. Where the given filePath has a root component then resolution is highly implementation dependent and therefore unspecified.
    
    Parameters:
    
    basePath - the base path considered as a directory
    
    filePath - the path to resolve against the basePath
    
    Returns:
    
    the resulting path
  - getAbsolutePath
```
protected abstract I getAbsolutePath(I path)
```
    Returns an object representing the absolute path for the given path.
    If the given path is already absolute then this method simply returns it. Otherwise, this method resolves the path in an implementation dependent manner, typically by resolving the path against a file system default directory. Depending on the implementation, this method may throw an I/O error if the file system is not accessible.
    
    Parameters:
    
    path - the given path
    
    Returns:
    
    the absolute path
  - pathToString
```
protected abstract String pathToString(I path)
```
    Returns:
    
    the path identified by <I> as a String.
  - doMkDirs
```
protected abstract void doMkDirs(I directoryPath)
```
    Creates the directory pointed by directoryPath.
    
    Parameters:
    
    directoryPath - the path to the directory you want to create

Class AbstractFileCommand<F extends FileSystem,I>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

fileSystem

Constructor Detail

AbstractFileCommand

Method Detail

exists

assureParentFolderExists

mkdirs

resolvePath

isVirtualDirectory

resolveExistingPath

cannotReadDirectoryException

cannotListFileException

pathNotFoundException

alreadyExistsException

exception

exception

getParent

getBasePath

resolvePath

getAbsolutePath

pathToString

doMkDirs