FileService ( Frame4J -- the Java framework de.frame4j... )

java.lang.Object
- de.frame4j.io.FileService

All Implemented Interfaces:

Serializable
```
@MinDoc(copyright="Copyright  2000 - 2009, 2015, 2021  A. Weinert",
        author="Albrecht Weinert",
        version="V.51",
        lastModified="7.06.2021",
        usage="use when multiple file and directories have to be worked on",
        purpose="file and directory services")
public class FileService
extends Object
implements Serializable
```
File and directory services.

Objects of this class support file and directory services. Therefore they have
1. an ample set of properties for those kind of services (like "act recursively on sub-directories too" recursion, "revert or equalise the roles of source and destination" (recursion respectively biDirect)
  as well as
2. the necessary criteria for the files (filCrit) and directories (dirCrit) to act on as two (associated) FileCriteria objects.
Point 2 is quite flexibly and comfortably implemented by the class FileCriteria.

Point 1 relates to the criteria and settings for the actions / services to do on the selected files and directories, like recursion, createLowerCase, noLCforTypes, delEmpty etc.. These properties form a fairly complete set for a very wide variety of services, so some of them are, of course not relevant, for a concrete service to be implemented. Examples of services / tools using FileService are de.frame4j.Update, FuR, de.frame4j.Del and SVNkeys, to name a few.

At first all properties and criteria of a FileService object have to be set. The most comfortable way is do do that in one step by the method set(PropMap) in one step using PropMap object with the right settings .
The second and last step is just to start the service (any service you can think of) by calling the method dirVisit(). It will visit all directories and files, that meet the selection criteria and other properties.

The kind of service so (simply) done will be determined by one to three (four) objects passed to the above method, which implement the simple interface FileVisitor. By providing up to three such objects one can (but must not) implement separately the single isolated action on
- a file,
- a non empty directors (visited before or after the recursive descend) and
- an empty directory.
If the same action is wanted in more than one circumstance, supply the same FileVisitor object. Is nothing to do specially in one of the cases, simply supply null.

In any case the FileVisitor's method FileVisitor.visit(File) implements the wanted action in each case. And that can be anything like even just do nothing, just list, delete, or even quit complex text operation like the Subversion (SVN) / CVS keyword beautifying for deployment by a tool like SVNkeys.
The use of the visitor pattern by Frame4J lets one do comfortably anythin with files and directories by just implementing the single action.

Figure 1: Visitor pattern using dirVisit()

A tool proceeding (like others) in that manner is FuR (Find and Replace on a set of files with arbitrary complex criteria). After preparing all criteria and text replacements (most of FuR's code) all text replacements on all files are just done by using the FileService object (here called dS):
```
       dS.dirVisit(path, null,  
               replaceBesucher,   // the visitor for files
               null, // visitor for empty directory (no action)
               null, // visitor for filled directory (no action)
               null); // dito for visit after content visiting
```
Implementation hint: Writing the FileVisitor as an inner class of the application / tool, as is done with replaceBesucher in FuR, gives that visitor access to all application information needed. (If just one visitor is needed it can, of course be directly implemented by the application class.

Via factory methods (makeOutputListVisitor(PrintWriter), makeOutputInfoVisitor(PrintWriter) and makeInCollectionVisitor()) this class offers three types of multiply usable FileVisitor object, used, of course, in Frame4J's tools.

Two often used file / directory services including all needed visitors are provided here too:
1. a comfortable and performing multistage backup and update service doUpdate() (used / wrapped in the tool de.frame4j.Update),
2. a supplementary cleaning service with optional backup doClean().
Implementation remarks on threading

The visits done by the method dirVisit(). and hence all calls to the the FileVisitor's methods FileVisitor.visit(File) come in a deterministic sequence in one thread. Hence, from this respect, those methods implementing FileVisitor don't have to be thread safe and don't have to bother with concurrency in their book keeping or whatever.

On the other hand (by this lack of concurrency as yet) complex (text) operations on hundreds of files — take FuR and SVNkeys as examples — are done sequentially adding their execution time. If the actions on single files (as in the example SVNkeys) were independent, concurrent execution would be allowed. The gain in time could be quite significant alone by not adding waits on I/O operations (even on just one core).

Future versions of this class may bring an "concurrency option" in the sense of acting on multiple files in parallel.

In between it is (under the condition of independence) possible for the application to supply a file visitor to the method dirVisit(... queuingVisitor ..) that returns at once delegating the real work (via aBlockingQueue) to an arbitrary number of working threads.

© Copyright 2000 - 2003, 2005, 2006 Albrecht Weinert
See Also:

FileHelper, FileHelper.OS, FileCriteria, doUpdate(File, File, File, PrintWriter), dirVisit(String, String, FileVisitor, FileVisitor, FileVisitor), Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`biDirect` Use both copy or update directions at once.
`protected boolean`	`createLowerCase` Make new files and directories with lower case names.
`protected boolean`	`delEmpty` Delete empty files (length 0) or directories (0 files, subdirectories).
`protected boolean`	`delEmptySource` Delete empty files or directories in the source directory.
`protected boolean`	`delTree` Delete directories, even when not empty.
`protected long`	`difOld` Minimal age difference of files.
`FileCriteria`	`dirCrit` Directory criteria.
`FileCriteria`	`filCrit` File criteria.
`protected boolean`	`makeDirs` Make not yet existing (sub) directories.
`protected String`	`noLCforTypes` Avoid lower casing names for specified types.
`protected boolean`	`nonew` No creation of non existing files.
`protected boolean`	`recursion` Recursively visit subdirectories.
`protected boolean`	`reverse` Reversing the copy or update direction.
`protected Verbos`	`verbosity` Verbosity of reports.
`protected boolean`	`zoneSafe` Summer / winter time switch precaution.

Constructor Summary

Constructors
Constructor and Description
`FileService()` Standard Constructor.
`FileService(FileCriteria filCrit, FileCriteria dirCrit, boolean recursion)` Constructor with criteria.
`FileService(FileService other)` Copy constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`dirVisit(String path, String name, FileVisitor fileBes, FileVisitor emptyDirBes, FileVisitor dirBes)` Working method to visit files and directories.
`void`	`dirVisit(String path, String name, FileVisitor fileBes, FileVisitor emptyDirBes, FileVisitor dirBes, FileVisitor dirBes2)` This FileVisitors working method to visit files and directories.
`int`	`doClean(File soD, File deD, File bcD, PrintWriter log)` Working method to clean up files and directories.
`int`	`doUpdate(File soD, File deD, File bcD, PrintWriter log)` Working method for dating or backing up files and directories.
`long`	`getDifOld()` Minimal age difference of files.
`String`	`getNoLCforTypes()` Avoid lower casing names for specified types.
`Verbos`	`getVerbosity()` Verbosity of reports.
`boolean`	`isBidirect()` Use both copy or update directions at once.
`boolean`	`isCreateLowerCase()` Make new files and directories with lower case names.
`boolean`	`isDelEmpty()` Delete empty files (length 0) or directories (0 files, subdirectories).
`boolean`	`isDelEmptySource()` Delete empty files or directories in the source directory.
`boolean`	`isDelTree()` Delete directories, even when not empty.
`boolean`	`isMakeDirs()` Make not yet existing (sub) directories.
`boolean`	`isNonew()` No creation of non existing files.
`boolean`	`isRecursion()` Recursively visit subdirectories..
`boolean`	`isReverse()` Reversing the copy or update direction.
`boolean`	`isZoneSafe()` Summer / winter time switch precaution.
`static FileVisitor`	`makeInCollectionVisitor(Collection<File> vec, boolean noDoub)` Produce a collecting visitor (a FileVisitor factory).
`static FileVisitor`	`makeOutputInfoVisitor(PrintWriter pos)` Produce an informing visitor (a FileVisitor factory).
`static FileVisitor`	`makeOutputListVisitor(PrintWriter pos)` Produce a listing visitor (a FileVisitor factory).
`void`	`set(PropMap prop)` Set the properties by a PropMap object.
`void`	`setBidirect(boolean biDirect)` Use both copy or update directions at once.
`void`	`setCreateLowerCase(boolean createLowerCase)` Make new files and directories with lower case names.
`void`	`setDelEmpty(boolean delEmpty)` Delete empty files (length 0) or directories (0 files, subdirectories).
`void`	`setDelEmptySource(boolean delEmptySource)` Delete empty files or directories in the source directory.
`void`	`setDelTree(boolean delTree)` Delete directories, even when not empty.
`void`	`setDifOld(long difOld)` Set the minimal age difference of files.
`void`	`setMakeDirs(boolean makeDirs)` Make not yet existing (sub) directories.
`void`	`setNoLCforTypes(String noLCforTypes)` Avoid lower casing names for specified types.
`void`	`setNonew(boolean nonew)` No creation of non existing files.
`void`	`setRecursion(boolean recursion)` Recursively visit subdirectories.
`void`	`setReverse(boolean reverse)` Reversing the copy or update direction.
`void`	`setZoneSafe(boolean zoneSafe)` Summer / winter time switch precaution.
`String`	`toString()` State as String.

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

- Field Detail
  - reverse
```
protected boolean reverse
```
    Reversing the copy or update direction.
    
    See Also:
    
    isReverse()
  - biDirect
```
protected boolean biDirect
```
    Use both copy or update directions at once.
    
    See Also:
    
    isBidirect()
  - delTree
```
protected boolean delTree
```
    Delete directories, even when not empty.
    
    See Also:
    
    isDelTree()
  - recursion
```
protected boolean recursion
```
    Recursively visit subdirectories.
    
    See Also:
    
    isRecursion()
  - delEmpty
```
protected boolean delEmpty
```
    Delete empty files (length 0) or directories (0 files, subdirectories).
    
    See Also:
    
    isDelEmpty()
  - delEmptySource
```
protected boolean delEmptySource
```
    Delete empty files or directories in the source directory.
    
    See Also:
    
    isDelEmptySource()
  - nonew
```
protected boolean nonew
```
    No creation of non existing files.
    
    See Also:
    
    isNonew()
  - makeDirs
```
protected boolean makeDirs
```
    Make not yet existing (sub) directories.
    
    See Also:
    
    isMakeDirs()
  - createLowerCase
```
protected boolean createLowerCase
```
    Make new files and directories with lower case names.
    
    See Also:
    
    isCreateLowerCase()
  - noLCforTypes
```
protected String noLCforTypes
```
    Avoid lower casing names for specified types.
    
    See Also:
    
    getNoLCforTypes()
  - verbosity
```
protected Verbos verbosity
```
    Verbosity of reports.
    
    See Also:
    
    getVerbosity()
  - difOld
```
protected long difOld
```
    Minimal age difference of files.
    
    See Also:
    
    getDifOld()
  - zoneSafe
```
protected boolean zoneSafe
```
    Summer / winter time switch precaution.
    
    See Also:
    
    isZoneSafe()
  - filCrit
```
public final FileCriteria filCrit
```
    File criteria.
    
    Two FileCriteria objects, filCrit and dirCrit, hold all (filter) criteria for files and directories for services / operations using this FileService object.
    
    Hint: The (questionable) decision of having those criteria public greatly simplified the implementation of those services.
  - dirCrit
```
public final FileCriteria dirCrit
```
    Directory criteria.
    
    See Also:
    
    filCrit
- Constructor Detail
  - FileService
```
public FileService()
```
    Standard Constructor.
    
    The associated filCrit and dirCrit are made in almost default (allow all files respectively all directories).
  - FileService
```
public FileService(FileCriteria filCrit,
                   FileCriteria dirCrit,
                   boolean recursion)
```
    Constructor with criteria.
    
    filCrit and dirCrit are taken in as a copy of the objects supplied.
  - FileService
```
public FileService(FileService other)
```
    Copy constructor.
    
    All fields and properties are copied from the other FileService object that must not be null.
- Method Detail
  - isReverse
```
public boolean isReverse()
```
    Reversing the copy or update direction.
    
    If true the roles of source and destination in all services is reversed. This feature might bring surprising and harmful results if used inadvertently.
    On the other hand it simplified the implementation (specification by .properties files) of complicated bidirectional update or synchronisation tasks so much, that it is indispensable there.
    
    default: false
  - setReverse
```
public void setReverse(boolean reverse)
```
    Reversing the copy or update direction.
    
    See Also:
    
    isReverse()
  - isBidirect
```
public boolean isBidirect()
```
    Use both copy or update directions at once.
    
    Contrary to reverse no services implemented in this class uses (obeys) this flag. It's here to make FileService more commonly usable.
    The in
    default: false
  - setBidirect
```
public void setBidirect(boolean biDirect)
```
    Use both copy or update directions at once.
    
    See Also:
    
    isBidirect()
  - isDelTree
```
public boolean isDelTree()
```
    Delete directories, even when not empty.
    
    default: false
  - setDelTree
```
public void setDelTree(boolean delTree)
```
    Delete directories, even when not empty.
    
    See Also:
    
    isDelTree()
  - isRecursion
```
public boolean isRecursion()
```
    Recursively visit subdirectories..
    
    default: false
  - setRecursion
```
public void setRecursion(boolean recursion)
```
    Recursively visit subdirectories.
    
    If recursion is set true here, dirCrit's allowDir will be set true also (which it normally should be anyway).
  - isDelEmpty
```
public boolean isDelEmpty()
```
    Delete empty files (length 0) or directories (0 files, subdirectories).
    
    Meaning for doClean():
    If true destination directories, that were or became empty, will be removed.
    
    Meaning for doUpdate():
    If both delEmptySource and delEmpty are true and if the (younger) source file has zero (0) length not only the corresponding destination file will be deleted, but (on success) this zero length source file also.
    
    Users of related services (like de.frame4j.Update) requested this just to have an acknowledge in the only directories (i.e. their source directories) the had access to.
    
    Hint: alternatively to this (file granular) delete by zero length one could comfortably run a doClean() to delete all destination files that don't exist in the source
    
    default: false
  - setDelEmpty
```
public void setDelEmpty(boolean delEmpty)
```
    Delete empty files (length 0) or directories (0 files, subdirectories).
    
    See Also:
    
    isDelEmpty()
  - isDelEmptySource
```
public boolean isDelEmptySource()
```
    Delete empty files or directories in the source directory.
    
    Hint: This property if true (and obeyed by a FileService based service) may result in modifying source directories, which might be semantically surprising.
    
    default: false;
  - setDelEmptySource
```
public void setDelEmptySource(boolean delEmptySource)
```
    Delete empty files or directories in the source directory.
    
    See Also:
    
    isDelEmptySource()
  - isNonew
```
public boolean isNonew()
```
    No creation of non existing files.
    
    Meaning for doUpdate():
    
    Files matching the criteria in the source directory will replace older ones in the destination directory. But, if a file of hat name does not yet exist in the destination, it will not be made.
    Nevertheless files replaced in destination directory will be made in / put to the backup directory even if not yet there in the case of multistage update.
    
    default: false
  - setNonew
```
public void setNonew(boolean nonew)
```
    No creation of non existing files.
    
    If nonew is set to false by this method makeDirs will be set so too.
    
    See Also:
    
    isNonew()
  - isMakeDirs
```
public boolean isMakeDirs()
```
    Make not yet existing (sub) directories.
    
    Meaning for doUpdate():
    
    If makeDirs is set false a destination directory needed by the existence of a matching source directory will not be made.
    Nevertheless if files are replaced in an existing destination directory the matching directory in the backup will be made in the case of multistage update.
    
    default: true
  - setMakeDirs
```
public void setMakeDirs(boolean makeDirs)
```
    Make not yet existing (sub) directories.
  - isCreateLowerCase
```
public boolean isCreateLowerCase()
```
    Make new files and directories with lower case names.
    
    If this property is true, for files and directories to be made the names will be used in lower case.
    
    default: false
    
    See Also:
    
    doUpdate()
  - setCreateLowerCase
```
public void setCreateLowerCase(boolean createLowerCase)
```
    Make new files and directories with lower case names.
    
    See Also:
    
    isCreateLowerCase()
  - getNoLCforTypes
```
public final String getNoLCforTypes()
```
    Avoid lower casing names for specified types.
    
    This property noLCforTypes has no effect if null or if createLowerCase is false.
    
    But if createLowerCase is true and noLCforTypes is a not empty list of types files of that type will be created in the case given by the source's name and not converted to lower case.
    
    default: .class;.java
    
    Rationale: In Java the source and the class file's name must exactly mirror the class' name. And as name convention required the first character being upper case, converting those file names to lower case would be in all cases erroneous.
    
    See Also:
    
    FileHelper.isOfType(File, CharSequence), setNoLCforTypes(String)
  - setNoLCforTypes
```
public void setNoLCforTypes(String noLCforTypes)
```
    Avoid lower casing names for specified types.
    
    See Also:
    
    getNoLCforTypes(), TextHelper.trimUq(CharSequence, String)
  - getVerbosity
```
public final Verbos getVerbosity()
```
    Verbosity of reports.
    
    Meaning and handling see at AppHelper.Verbos.toString().
    For values <= TEST all implemented services shall show no effect to the out side world, i.e. manipulate no files or directories.
    
    default: Verbos.NORMAL (10)
    
    See Also:
    
    Verbos.SILENT, Verbos.NORMAL, Verbos.VERBOSE, Verbos.DEBUG, Verbos.TEST
  - getDifOld
```
public long getDifOld()
```
    Minimal age difference of files.
    
    If >= 0 the value is the minimum age difference in milliseconds above which to files will be considered of different age.
    
    A value of -1 means ignore / don't use age as criterion. For the method / service doUpdate(File, File, File, PrintWriter) that means the switch to "hard" XCopy behaviour.
    
    A value of -2 means that an existing file will not be replaced no matter which (source or destination) is newer. This is a "no replace" behaviour. (See option -noReplace in de.frame4j.Update.)
    
    default: 0L
    
    See Also:
    
    doUpdate()
  - setDifOld
```
public void setDifOld(long difOld)
```
    Set the minimal age difference of files.
    
    A parameter value difOld < 0 and difOld != -2 will be taken as -1.
    
    See Also:
    
    getDifOld()
  - isZoneSafe
```
public boolean isZoneSafe()
```
    Summer / winter time switch precaution.
    
    If zoneSafe is true and the files considered are older than three days the minimal age difference is effectively raised to three hours, if difOld is less three hours and >= 0.
    
    default: false
    
    See Also:
    
    setZoneSafe(boolean), getDifOld(), doUpdate(File, File, File, PrintWriter)
  - setZoneSafe
```
public void setZoneSafe(boolean zoneSafe)
```
    Summer / winter time switch precaution.
    
    See Also:
    
    isZoneSafe()
  - set
```
public void set(PropMap prop)
         throws IllegalArgumentException
```
    Set the properties by a PropMap object.
    
    The properties and the criteria of this FileService object will be set by the provided PropMap's following properties (if given):
    - verbosity
    - recursion
    - zoneSafe
    - lcNames sets createLowerCase
    - noLCforTypes
    - delEmpty
    - delEmptySource
    - reverse
    - biDirect
    - delTree
    - difOld
    - noMd
      not noMd sets makeDirs.
    - noNew
      sets nonew.
    - ignoreCase
      sets ignoreCase in dirCrit and in filCrit.
    - thoseDirs
      sets wildName in dirCrit.
    - omitDirs and omitExtraDirs
      set the excludeNames in dirCrit.
    - types respectively thoseFiles
      sets wildName in filCrit.
    - omitFiles and omitExtraFiles
      set the excludeNames in filCrit.
    - days
      > 0 sets the time range in filCrit to "since days * 24 h before now until ... ".
      If this property exists it must be "nosetting" (which is then of no effect) of it must be parsable as an whole number > 0. Otherwise there will be an exception.
    - daysOld
      > 0 sets den the time range in filCrit to "from ... until days * 24 h before now".
      If this property exists it must be "nosetting" (which is then of no effect) of it must be parsable as an whole number > 0. Otherwise there will be an exception.
    - minTime respectively since and maxTime respectively til
      > set the time range in filCrit.
      If one or both of these properties are there, they have to be parsable according to the (ample) possibilities of TimeHelper.parse() as a time. Otherwise an Exception will occur. The same will occur if the time boundary in case will also be defined by property days respectively daysOld.
    - minLen and maxLen
      > set the length range in filCrit.
    Is one of the named properties not contained (non empty) in prop (or prop itself is null) nothing happens in each case.
    Parameters:
    
    prop - a Map containing the properties to set. In applications / tools this will most often be the App's own PropMap
    
    Throws:
    
    IllegalArgumentException - in case of wrong or contradictory (like since as well as days) properties
  - toString
```
public String toString()
```
    State as String.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    the properties as multi-line text
  - doUpdate
```
public final int doUpdate(File soD,
                          File deD,
                          File bcD,
                          PrintWriter log)
```
    Working method for dating or backing up files and directories.
    
    According to the criteria and properties of this FileService object files will be copied from a source directory soD to a destination directory deD. If ordered so, files before being replaced in the destination directory may be copied before to a backup directory bcD.
    The property reverse if true will interchange the roles of destination and source, i.e. soD and deD.
    
    Copying / updating can also be done recursively including sub-directories. The than perhaps required making of destinations's new sub-directories would be done automatically, but can be forbidden.
    
    In the same manner the making of files not existing in the source can be forbidden, restricting the service to the mere updating of destination's existing files (nonew).
    Taking the other extreme it is as well possible to prohibit all overwriting of destination's existing files, restricting the service to just adding new files (noRepalce).
    
    Otherwise that rule applies:
    A file will copied from source to destination if it does not exist there or if it is sufficiently older than in source.
    A value -1 of difOld makes the copying independent of age (xcopy option).
    If the source file has a length of zero bytes (bearing hardly any information besides its existence and attributes) deleting can be chosen instead of copying (optionally deleting this 0 length source file on success).
    
    Attention: If source and destination are on different computers (network nodes) different time keeping strategies especially when (automatic) handling of daylight saving is involved can have quite surprising effects on any update services including this one. Here difOLd and zoneSafe can form a line of defence (of proven efficiency in many those circumstances).
    Similar warning (and remedies) apply among others for removable disks, CDS, DVDs, USB sticks or even partitions using different file systems and time formats / resolutions.
    
    A file that will be overwritten or deleted in the source directory will beforehand be copied to the backup directory if bcD if that is given.
    
    Hint on I/O problems: The method File.list() used here to also on descending to sub-directories returns null on I/O error. This will be logged if possible. That event will, of course, halt further descending recursively from this directory, just as if would contain no sub-directories (be that true or not).
    
    Parameters:
    
    soD - source directory
    
    deD - destination directory
    
    bcD - backup directory or null, if no "two stage " backup wanted.
    
    log - for reports or null, if no logging at all is asked for
    
    Returns:
    
    total number of files copied or deleted
  - doClean
```
public final int doClean(File soD,
                         File deD,
                         File bcD,
                         PrintWriter log)
```
    Working method to clean up files and directories.
    
    According to the criteria and properties of this FileService object files will be deleted in the destination directory deD if the related file does not exist in the source directory soD.
    If a soD directory is not specified or does not exist, the latter condition is regarded as fulfilled: the file will be deleted.
    
    If ordered so files, before being deleted in the destination directory may be copied before to a backup directory bcD.
    The deleting can also be done recursively including sub-directories.
    
    The property reverse if true will interchange the roles of destination and source, i.e. soD and deD.
    
    deD must denote an existing directory.
    soD and bcD may be null, denote and existing or not existing directory, but never an existing file.
    
    Parameters:
    
    soD - source directory (acts quasi as list of files and directories NOT to be deleted)
    
    deD - destination directory (it's here where the cleaning work is done)
    
    bcD - backup directory for files deleted in deD or null, if no two stage clean up is asked for. (must not be a file!)
    
    log - for reports or null, if no logging at all is asked for
    
    Returns:
    
    total number of files copied or deleted
    
    Since:
    
    31.05.2002
    
    See Also:
    
    doUpdate()
  - dirVisit
```
public final void dirVisit(String path,
                           String name,
                           FileVisitor fileBes,
                           FileVisitor emptyDirBes,
                           FileVisitor dirBes,
                           FileVisitor dirBes2)
```
    This FileVisitors working method to visit files and directories.
    
    If path and name denote exactly any one file it will be visited calling filBes.visit() if fileBes is not null. "Any one file" in this means all that could mean an existing or not existing file but not an existing directory.
    
    If path and name denote an existing directory all files matching filCrit and all directories matching dirCrit are determined. (Its an internal snapshot of that diretory's state.) Then the following is done:
    1. If these snapshot lists are both empty emptyDirBes.visit() will be called for that regarded (start) directory. And that's all.
    2. dirBes.visit() will be called for that regarded (start) directory as a "pre-visit".
    3. filBes.visit() will be called for all the listed files (matching filCrit).
    4. If (@link recursion is false dirBes.visit() will be called for all directories in the snapshot list (matching dirCrit) be they empty or not.
      The next step will be omitted.
    5. If (@link recursion is true the whole proceeding will be done for every directory in the snapshot list (matching dirCrit). (That is done, of course, by by calling this method recursively.)
    6. At last after visiting all matching files and directories contained dirBes2.visit() will be called for that regarded (start) directory as a "post-visit".
    What is done on the visited files or directories is totally the matter (and responsibility) of the supplied one to four visitors, some of which might of course be null or the same if no or equal action is wanted.
    Parameters:
    
    path - the start (parent) path (not null!)
    
    name - the start file or directory; may be null if completely included in path
    
    fileBes - implements the action on each file in case (matching filCrit)
    
    emptyDirBes - implements the action on the (start) directory if it contains neither files nor directories matching the criteria (dirCrit or filCrit); "empty" means nothing with respect to those criteria.
    
    dirBes - implements a) on one hand implements the action on the (start) directory if it is not empty in the above sense.
    b) On the other hand dirBes implements the action on each directory matching dirCrit.
    Hint: Recursive descend is organised by this method and not the task of the visitor dirBes (that will be called in role a) in that case).
    
    dirBes2 - implements the action on the (start) directory do be done after returning from all file and / or directory visits on its content.
  - dirVisit
```
public final void dirVisit(String path,
                           String name,
                           FileVisitor fileBes,
                           FileVisitor emptyDirBes,
                           FileVisitor dirBes)
```
    Working method to visit files and directories.
    
    The call is equivalent to
    dirVisit(path, name, fileBes, emptyDirBes, dirBes, null)
    as shorter notation for cases without "post visitor" (on tree ascend) on non mepty directories.
  - makeOutputListVisitor
```
public static FileVisitor makeOutputListVisitor(PrintWriter pos)
```
    Produce a listing visitor (a FileVisitor factory).
    
    The FileVisitor object made by this method just lists all visited Files on the PrintWriter provided.
    The returned FileVisitor's method visit(File dD) returns 0 as normal, -1 if pos is null and -2 if the provided File dD is null.
    
    Parameters:
    
    pos - the list output (null is accepted but makes no sense)
    
    Returns:
    
    a listing FileVisitor
    
    See Also:
    
    FileVisitor, FileHelper.listLine(File)
  - makeOutputInfoVisitor
```
public static FileVisitor makeOutputInfoVisitor(PrintWriter pos)
```
    Produce an informing visitor (a FileVisitor factory).
    
    The FileVisitor object made by this method just lists all visited Files on the PrintWriter provided.
    The returned FileVisitor's method visit(File dD) returns 0 as normal, -1 if pos is null and -2 if the provided File dD is null.
    
    Parameters:
    
    pos - the list output (null is accepted but makes no sense)
    
    Returns:
    
    a listing FileVisitor
    
    See Also:
    
    FileVisitor, FileHelper.infoLine(File)
  - makeInCollectionVisitor
```
public static FileVisitor makeInCollectionVisitor(Collection<File> vec,
                                                  boolean noDoub)
```
    Produce a collecting visitor (a FileVisitor factory).
    
    The FileVisitor object made by this method just puts all visited Files into the Collection provided.
    The returned FileVisitor's method visit(File dD) returns 0 as normal, -1 if vec is null and -2 if the provided File dD is null. null is not put into vec.
    
    Parameters:
    
    vec - the collecting container
    
    noDoub - do not enter a File twice; i.e. enforce set behaviour even if vec if not of type Set
    
    Returns:
    
    a listing/collecting FileVisitor

Class FileService

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

reverse

biDirect

delTree

recursion

delEmpty

delEmptySource

nonew

makeDirs

createLowerCase

noLCforTypes

verbosity

difOld

zoneSafe

filCrit

dirCrit

Constructor Detail

FileService

FileService

FileService

Method Detail

isReverse

setReverse

isBidirect

setBidirect

isDelTree

setDelTree

isRecursion

setRecursion

isDelEmpty

setDelEmpty

isDelEmptySource

setDelEmptySource

isNonew

setNonew

isMakeDirs

setMakeDirs

isCreateLowerCase

setCreateLowerCase

getNoLCforTypes

setNoLCforTypes

getVerbosity

getDifOld

setDifOld

isZoneSafe

setZoneSafe

set

toString

doUpdate

doClean

dirVisit

dirVisit

makeOutputListVisitor

makeOutputInfoVisitor

makeInCollectionVisitor