FileRemote

java.lang.Object
- java.io.File
- - org.vishia.fileRemote.FileRemote

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<java.io.File>, MarkMask_ifc, TreeNodeNamed_ifc

Direct Known Subclasses:

FileZip
```
public class FileRemote
extends java.io.File
implements MarkMask_ifc, TreeNodeNamed_ifc
```
This class stores the name, some attributes of one File and also a List of all children if the file is a directory. This class inherites from javaio.File to provide all capabilities of File but it does not immediately or never use the implementation of File. All operations are overridden. The implementation is part of the aggregated device which may use the capabilities of java.io.File or also java.nio.files.
The file may be localized on any maybe remote device or it may be a normal file in the operation system's file tree. The information about the file (date, size, attributes) are stored locally in the instance of this class, hence they are accessible in a fast way without operation system access. But therefore they can be correct or not: A file on its data storage can be changed or removed. The data of this class should be refreshed if it seems to be necessary.
Such an refresh operation can be done if there is enough time, no traffic on system level. Then the information about the file may be actual and fast accessible if an application needs one of them.

In comparison to the standard File, there the information are gotten from the operation system in any case, the access is correct but can be slow especially the file is located anywhere in network or in a specific device.

A remote file should be accessed by FileRemoteAccessor implementations referenced with device. It may be any information on an embedded hardware, not only in a standard network. For example the access to zip archives are implemented by FileAccessZip. A file can be present only with one line in a text document which contains path, size, date. In this case the content is not available, but the properties of the file. See FileList.
This class stores the following information (overview)
- path, timestamp, length, flags for read/write etc. like known for file systems.
- parent and children of this file in its file tree context.
- time of last refresh: timeRefresh and timeChildren. With this information an application can decide whether the file should be #refreshProperties(CallbackEvent) or whether its propertees seems to be actual valid.
- Aggregation to its FileRemoteAccessor: device to refresh.
- Aggregation to any data which are necessary to access the physical file for the FileRemoteAccessor implementation. This is an instance of File for local files.
- Aggregation to its FileCluster: itsCluster. The cluster assures that only one FileRemote instance exists for one physical file inside an application. In this case some additional properties can be stored to the FileRemote instance like selected etc. which are seen application-width.
- Information about a mark state. There are some bits for simple mark or for mark that it is equal, new etc. in any comparison. This bits can be used by applications.
The cluster of files, clusterOfApplication:
The FileCluster assures that any file has only exact one FileRemote instance as presentation. On the one hand this prevents too many access to the file system. If the instance is refreshed a short time ago then it should not be refreshed for the same physical file in another instance.
The other aspect is: If a file is marked, it is marked for the whole application. Marking (setMarked(int) is not supported by a file system itself but it is supported here. The itsCluster for a file (usual the clusterOfApplication) is independent of the device() which is the reference to the file system implementor.

How to create instances of this class?
The constructor of this class is protected, hence only internally accessible. To create a FileRemote instance you can use
- fromFile(File) if you have already given a java.io.File instance.
- get(String) with relative or absolute given path.
- getDir(CharSequence) explicitely get or create a directory
- getFile(CharSequence, CharSequence) in opposite to get(String) with dispersed directory path and name
- child(CharSequence) from a given FileRemote as directory
- child(CharSequence, int, int, long, long, long) to create a child with partially known properties
- subdir(CharSequence) to get or create definitely a directory inside a given FileRemote directory.
All these operations do not access the real file system. Instead they search in the clusterOfApplication whether the file is already known and returns it, or they create and register the adequate FileRemote instance in the cluster. The FileRemote instance should/can be synchronized with the real file instance by calling #refreshProperties(CallbackEvent) or for directory instances with #refreshPropertiesAndChildren() from the local file system you can call fromFile(File). This delegates working to #fromFile(FileCluster, File) with the static given clusterOfApplication which looks whether the FileRemote instance is existing already, or registeres it in the file cluster. The implementor of the file system depends on the given path.
You can create a child of an existing file by given FileRemote directory instance using child(CharSequence), subdir(CharSequence) or child(CharSequence, int, int, long, long, long) whereby the child can be a deeper one, the path is a relative path from the given parent. This FileRemote instance describes a possible existing file or maybe a non existing one, adequate like creation of instance of File. Note that on #refreshPropertiesAndChildren(CallbackEvent) this instance will be removed from the children list if it is not existing.
You can get any FileRemote instance with any absolute path calling FileCluster#getFile(CharSequence). This instance will be created if it is not existing, or it will be get from an existing instance of this RemoteFile inside the cluster. The instance won't be deleted if the physical file is not existing. For example you can create
```
   FileRemote testFile = theFileCluster.getFile("X:/MyPath/file.ext");
 
```
This instance is existing independent of the existence of such a physical file. But
```
   if(testFile.exists()){....
 
```
may return false.

This class inherits from File in the determination as interface. The advantage is:
- The class File defines a proper interface to deal with files which can be used for the remote files concept too. No extra definition of access methods is need.
- Any reference to an instance of this class can be store as reference of type java.io.File. The user can deal with it without knowledge about the FileRemote concept in a part of its software. Only the refreshing should be regulated in the proper part of the application.
Concepts of callback:
A callback is an instance of the FileRemoteWalkerCallback which is given either by the application or given for specific commands in the implementation in the device. It is used to do actions with any (selected) file or directory.
This class offers some methods to deal with directory trees:
- #refreshAndMark(int, boolean, String, int, int, FileRemoteWalkerCallback) marks files for copy, move or delete.
- #refreshAndCompare(FileRemote, int, String, int, FileRemoteProgressEvData) compares two trees of files.
- #copyChecked(String, String, int, CallbackEvent) copies some or all files in a tree.
- #deleteChecked(CallbackEvent, int) deletes some or all files in a tree.
This operations may need more seconds, sometimes till minutes if there are a lot of files in a remote device with network access. To show the progress two startegies are used:
- FileRemoteWalkerCallback: It is a callback interface with methods for each file and each started and finished directory.
- FileRemoteProgressEvData: It is an instance which is filled with data. The time order is handled by a timer which activates it for example in a cycle for 200 milliseconds. The user extends this base class with the showing method. In a time range of 200 milliseconds there can be executed some more files, for example 1000 if the file system is local. Not any file forces to be showed. Therewith calculation time is saved.
The user can provide one of that, both or no instance for showing. Handling of a event driven communication need one event per file. It is too much effort if the file system is fast. That is tested in the past but not supported furthermore.

Concepts of feedback with events:
There are three concepts generally in software how to deal with feedback:
- a) offer a return value which contains feedback information
- b) throw an exception if any stuff is wrong, if all is ok, then no further feedback is given. All is ok.
- c) send an event
All three possibilities are usual in Java programming and especially for file handling:
- a) is used for example for File.mkdir() or File.delete(). This operations are the first in the Java of the 1990th presuming a simple file system.
- b) Exception handling becomes very familiar for Java programming, used overall. For example Reader.read(char[]) does not return a negative number on reading error which may be possible, instead throws. An FileReader.open() which may return an information does not exist, instead the constructor is used for open, which throws an exception if the file does not exist. This means effort for exception handling though the situation of a non existing file is expectable. Exception handling should be intrinsically only done on real faulty situations.
- c) Event handling is a little bit unusual in Java programming, else for graphic applications.
Because the operations of this class are frequently used also in graphic applications, the event handling should be the first choice. But some operations compatible to File needs a). Exception handling is done only on really exceptions.

The second question is: Execute the file handling in an extra thread.

The solution is the following:
- All operations can be called via a given back or progress event instance. The type of the back event is EventWithDst with FileRemoteProgressEvData as data type. The back or progress event can be used also to get information about the progress of a longer operation, for example copy long files. But it is also used for the success or error information.
- Operations which can be executed in the same thread returns a String information if something is wrong but expectable. exception throwing is used only on really exceptions or it comes from the implementation level. The return String is null if all is ok.
- On access to a really remote file system using the same thread is not possible because communication is necessary. Hence general using the back event is recommended if the file system may be remote. The return value can only present whether or not the communication was initiated.
- The decision using the same thread (the operation may be need a longer time for example on access via network) or using an extra (given, prepared) thread if it is possible to do the action in the same thread depends on the offering the back event. If it is given, the action is executed in an extra thread.
- But for some test cases or application specific the back event can be given as information destination, and nevertheless the same thread should be used. This decision is set as information in the
- The back event can be absent. Then detail information about the progress are not possible. If the
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`FileRemote.CallbackEvent` Type for callback notification for any action with remote files.
`static class`	`FileRemote.Ecmp` Possibilities for comparison.
`static interface`	`FileRemote.FileRemoteAccessorSelector` interface to build an instance, which decides about the instance for physical access to files in knowledge of the path.
`class`	`FileRemote.InternalAccess` This inner non static class is only intent to access from a FileRemoteAccessor to any file.
`static class`	`FileRemote.XXXCallbackCmd` Designates that the copy process which was forced forward with this callback should be stopped and aborted.

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`_ident` A indent number, Primarily for debug and test.
`private FileRemote.InternalAccess`	`acc_`
`private static FileRemote.FileRemoteAccessorSelector`	`accessorSelector` Instance of the application-width selector for `FileRemoteAccessor`.
`private java.util.Map<java.lang.String,FileRemote>`	`children` The content of a directory.
`static FileCluster`	`clusterOfApplication` This cluster is used if a specific cluster should not be used.
`private static int`	`ctIdent` Counter, any instance has an ident number.
`protected long`	`date` Timestamp of the file.
`protected long`	`dateCreation` Timestamp of the file.
`protected long`	`dateLastAccess` Timestamp of the file.
`protected FileRemoteAccessor`	`device` The device which manages the physical files.
`(package private) EventSource`	`evSrc`
`protected int`	`flags` Some flag bits.
`FileCluster`	`itsCluster` Any FileRemote instance should be member of a FileCluster.
`protected long`	`length` Length of the file.
`static int`	`mAbsPath` Type of given path.
`protected FileMark`	`mark` A mark and count instance for this file.
`static int`	`mCanRead` Info about the file stored in `flags` returned with `getFlags()`.
`static int`	`mCanReadAny` Group and any read and write permissions.
`static int`	`mCanReadGrp` Group and any read and write permissions.
`static int`	`mCanWrite` Info about the file stored in `flags` returned with `getFlags()`.
`static int`	`mCanWriteAny` Group and any read and write permissions.
`static int`	`mCanWriteGrp` Group and any read and write permissions.
`static int`	`mDirectory` Info whether the File is a directory.
`static int`	`mExecute` Info whether it is an executable (executable flag on unix)
`static int`	`mExecuteAny` Info whether it is an executable (executable flag on unix)
`static int`	`mExecuteGrp` Group and any read and write permissions.
`static int`	`mExist` Info about the file stored in `flags` returned with `getFlags()`.
`static int`	`mFile` Info whether the File is a directory.
`static int`	`mHidden` Info about the file stored in `flags` returned with `getFlags()`.
`static int`	`modeCmprLogComparedFiles` Bits for the logging mode of `#cmprDirs(File, File, String, List)`.
`static int`	`modeCmprLogMissing1File` Bits for the logging mode of `#cmprDirs(File, File, String, List)`.
`static int`	`modeCmprLogMissing2File` Bits for the logging mode of `#cmprDirs(File, File, String, List)`.
`static int`	`modeCmprLogNotEqualFiles` Bits for the logging mode of `#cmprDirs(File, File, String, List)`.
`static int`	`modeCopyCreateAsk`
`static int`	`modeCopyCreateMask`
`static int`	`modeCopyCreateNever`
`static int`	`modeCopyCreateYes`
`static int`	`modeCopyExistAll`
`static int`	`modeCopyExistAsk`
`static int`	`modeCopyExistMask`
`static int`	`modeCopyExistNewer`
`static int`	`modeCopyExistOlder`
`static int`	`modeCopyExistSkip`
`static int`	`modeCopyReadOnlyAks`
`static int`	`modeCopyReadOnlyMask`
`static int`	`modeCopyReadOnlyNever`
`static int`	`modeCopyReadOnlyOverwrite`
`static int`	`mRefreshChildPending` Set if the file is removed yet because a refresh is pending.
`static int`	`mRelativePath` Type of given path.
`static int`	`mRoot` Set if it is a root directory.
`static int`	`mShouldRefresh` Flags as result of an comparison: the other file exist but its content is different.
`static int`	`mSymLinkedPath` A symbolic link in unix.
`static int`	`mTested` Set if the file is tested physically.
`static int`	`mThreadIsRunning` Set if a thread runs to get file properties.
`(package private) java.lang.Object`	`oFile` This is the internal file object.
`(package private) FileRemote`	`parent` The parent instance, it is the directory where the file is member of.
`protected java.nio.file.Path`	`path` can be null or set with the valid path.
`protected java.lang.String`	`sCanonicalPath` The unique path to the file or directory entry.
`protected java.lang.String`	`sDir` The directory path of the file.
`private static long`	`serialVersionUID`
`protected java.lang.String`	`sFile` The name with extension of the file or directory name.
`long`	`timeChildren` The last time where the file was synchronized with its physical properties.
`long`	`timeRefresh` The last time where the file was synchronized with its physical properties.
`static java.lang.String`	`version` Version, history and license.

Fields inherited from class java.io.File
pathSeparator, pathSeparatorChar, separator, separatorChar

Fields inherited from interface org.vishia.util.MarkMask_ifc
select, select2, select2Parent, selectParent

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`FileRemote(FileCluster cluster, FileRemoteAccessor device, FileRemote parent, java.lang.CharSequence sPath, long length, long dateLastModified, long dateCreation, long dateLastAccess, int flags, java.lang.Object oFileP, boolean OnlySpecialCall)` Constructs an instance.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`_setProperties(long length, long date, long dateCreation, long dateAccess, int flags, java.lang.Object oFileP)` Sets the properties to this.
`void`	`abortAction()` It sends an abort event to the execution thread or to any remote device to abort any action with files.
`boolean`	`canExecute()` true if due to Java orientation to the file system the file is executable.
`boolean`	`canRead()` true if due to Java orientation to the file system the file is readable (visible).
`boolean`	`canWrite()` true if due to Java orientation to the file system the file is not read only.
`void`	`check(java.lang.String sFiles, java.lang.String sWildcardSelection, FileRemoteProgressEvData evback)` Deprecated.
`void`	`chgProps(boolean bWait, java.lang.String newName, int maskFlags, int newFlags, long newDate, EventWithDst<FileRemoteProgressEvData,?> evBack)` Change the file properties maybe in a remote device.
`void`	`chgPropsRecursive(int maskFlags, int newFlags, long newDate, EventWithDst<FileRemoteProgressEvData,?> evBack)` Change the file properties maybe in a remote device.
`FileRemote`	`child(java.lang.CharSequence sPathChild)` Gets or creates a child with the given name.
`private FileRemote`	`child(java.lang.CharSequence sPathChild, int flags, int length, long dateLastModified, long dateCreation, long dateLastAccess)` Returns the instance of FileRemote which is the child of this.
`java.util.Map<java.lang.String,FileRemote>`	`children()` Gets the Index of the children sorted by name.
`void`	`cleanChildren()` Cleans the children list.
`void`	`cmdRemote(FileRemoteCmdEventData.Cmd cmd, FileRemote dstdir, java.lang.String selectFilter, int cycleProgress, int depthWalk, FileRemoteCmdEventData cmdDataArg, EventWithDst<FileRemoteProgressEvData,?> progressEv)` This is the basic operation to force execution with this file or dir either on another device or in another thread, depending on its `device()`.
`void`	`cmprDirTreeTo(boolean bWait, FileRemote dir2, java.lang.String mask, EventWithDst<FileRemoteProgressEvData,?> evBack)` Refreshes a file tree and compare some or all files.
`void`	`copyChecked(java.lang.String pathDst, java.lang.String nameModification, int mode, FileRemoteWalkerCallback callbackUser, FileRemoteProgressEvData timeOrderProgress)` Copies all files which are checked before.
`void`	`copyDirTreeTo(boolean bWait, FileRemote dirDst, int depth, int markSet, int markSetDir, java.lang.String selectFilter, int selectMask, EventWithDst<FileRemoteProgressEvData,?> evBack)`
`void`	`copyDirTreeTo(boolean bWait, FileRemote dirDst, int depth, java.lang.String mask, EventWithDst<FileRemoteProgressEvData,?> evBack)`
`java.lang.String`	`copyTo(FileRemote dst, EventWithDst<FileRemoteProgressEvData,?> evBack)`
`void`	`copyTo(FileRemote dst, EventWithDst<FileRemoteProgressEvData,?> evBack, int mode)` Copies a file or directory tree to another file in the same device.
`void`	`countAllFileLength(EventWithDst<FileRemoteProgressEvData,?> evBack)` Count the sum of length of all files in this directory tree.
`static java.util.Map<java.lang.String,FileRemote>`	`createChildrenList()` Method to create a children list.
`boolean`	`createNewFile()`
`long`	`creationTime()` Returns the creation time of the file if the file system supports it.
`boolean`	`delete()` Deletes this file, correct the parent's children list, remove this file.
`void`	`delete(EventWithDst<FileRemoteProgressEvData,?> evBack)` Deletes a file maybe in a remote device.
`void`	`deleteFilesDirTree(boolean bWait, int depth, java.lang.String mask, EventWithDst<FileRemoteProgressEvData,?> evBack)`
`FileRemoteAccessor`	`device()`
`boolean`	`exists()` Returns true if the file seems to be existing.
`java.io.File`	`file()`
`static FileRemote`	`fromFile(java.io.File src)` Returns a FileRemote instance from a standard java.io.File instance.
`static FileRemote`	`get(FileCluster cluster, java.lang.String filePath)`
`static FileRemote`	`get(java.lang.String filePath)` Gets an existing FileRemote instance or creates a new one.
`java.lang.String`	`getAbsolutePath()`
`static FileRemote.FileRemoteAccessorSelector`	`getAccessorSelector()`
`java.lang.String`	`getCanonicalPath()`
`FileRemote`	`getChild(java.lang.CharSequence name)`
`FileMark`	`getCreateMark()` Gets or creates a `FileMark` for this file.
`static FileRemote`	`getDir(java.lang.CharSequence dirPath)` Returns the instance which is associated to the given directory.
`static FileRemote`	`getDir(FileCluster cluster, java.lang.CharSequence dirPath)` Returns the instance which is associated to the given directory.
`java.lang.CharSequence`	`getDirChars()`
`static FileRemote`	`getFile(java.lang.CharSequence dir, java.lang.CharSequence name)` Returns the instance which is associated to the given directory and name.
`static FileRemote`	`getFile(FileCluster cluster, java.lang.CharSequence dirPath, java.lang.CharSequence name)` Returns the instance which is associated to the given directory and the file in this directory.
`int`	`getFlags()`
`int`	`getFlagsTested()` Return the flags of the file after tested with file system itself.
`int`	`getMark()` Returns the mark of a `mark` or 0 if it is not present.
`java.lang.String`	`getName()`
`java.lang.String`	`getParent()` Returns the parent path, it is the directory path.
`FileRemote`	`getParentFile()` Gets the parent directory.
`java.lang.String`	`getPath()` Gets the path of the file.
`java.lang.CharSequence`	`getPathChars()` Returns the same as `getPath()` for files, but ends with '/' if this is a directory.
`java.lang.CharSequence`	`getStateDevice()` Returns the state of the device statemachine, to detect whether it is active or ready.
`int`	`ident()`
`FileRemote.InternalAccess`	`internalAccess()` This routine is only intent to access from a FileRemoteAccessor to any file.
`java.lang.CharSequence`	`isChild(java.lang.CharSequence path)` Checks whether the given path describes a child (any deepness) of this file and returns the normalized child string.
`boolean`	`isDirectory()` Returns true if the FileRemote instance was created as directory or if any `#refreshProperties(CallbackEvent)` call before this call has detected that it is an directory.
`boolean`	`isFile()` TODO mFile is not set yet, use !
`boolean`	`isHidden()` TODO mFile is not set yet, use !
`boolean`	`isMarked(int mask)`
`java.lang.CharSequence`	`isParent(java.lang.CharSequence path)` Checks whether the given path describes a parent (any deepness) of this file and returns the normalized child string.
`boolean`	`isRoot()`
`boolean`	`isSymbolicLink()`
`boolean`	`isTested()` Returns true if the file was tested in the past.
`boolean`	`isTested(long since)` Returns true if the last time of refreshing is newer than since.
`long`	`lastAccessTime()` Returns the last access time of the file if the file system supports it.
`long`	`lastModified()`
`long`	`length()`
`FileRemote[]`	`listFiles()` This method overrides java.io.File.listFiles() but returns Objects from this class type.
`java.io.File[]`	`listFiles(java.io.FileFilter filter)`
`FileMark`	`mark()` Gets the `FileMark` for this file or null if not marked in any kind.
`boolean`	`mkdir()` Creates the directory named by this abstract pathname.
`java.lang.String`	`mkdir(boolean recursively, EventWithDst<FileRemoteProgressEvData,FileRemoteCmdEventData> evBack)` Creates the directory named by this abstract pathname
`boolean`	`mkdirs()` Creates the directory named by this abstract pathname , including any necessary but nonexistent parent directories.
`void`	`moveTo(java.lang.String sFiles, FileRemote dst, FileRemoteProgressEvData evback)` Moves this file or some files in this directory to another file(s) maybe in a remote device.
`java.lang.Object`	`oFile()`
`java.io.InputStream`	`openInputStream(long passPhrase)` Opens a read access to this file.
`java.io.OutputStream`	`openOutputStream(long passPhrase)` Opens a write access to this file.
`java.nio.channels.ReadableByteChannel`	`openRead(long passPhrase)` Opens a read access to this file.
`java.nio.channels.WritableByteChannel`	`openWrite(long passPhrase)` Opens a write access to this file.
`java.nio.file.Path`	`path()`
`(package private) void`	`putNewChild(FileRemote child)`
`void`	`refreshAndMark(boolean bWait, int depth, int setMark, int setMarkDir, java.lang.String sMaskSelection, long markSelection, FileRemoteWalkerCallback callbackUser, EventWithDst<FileRemoteProgressEvData,?> evBack)` Refreshes a file tree and mark some files.
`void`	`refreshAndSearch(int depth, java.lang.String mask, int mark, byte[] search, FileRemoteWalkerCallback callbackUser, EventWithDst<FileRemoteProgressEvData,?> evBack)` Refreshes a file tree and search in some or all files.
`void`	`refreshProperties()` Gets the properties of the file from the physical file immediately in this thread.
`void`	`refreshProperties(EventWithDst<FileRemoteProgressEvData,?> evBack)` Gets the properties of the file from the physical file.
`void`	`refreshPropertiesAndChildren(boolean bWait, EventWithDst<FileRemoteProgressEvData,?> evBack)` Refreshes the properties of this file and gets all children in an extra thread with user-callback for any file.
`boolean`	`renameTo(java.io.File dst)` renames or moves this file to the given path in dst.
`java.lang.String`	`renameTo(FileRemote dst, EventWithDst<FileRemoteProgressEvData,?> evBack)`
`long`	`resetMarked(int mask)` Resets the mark bits of this file.
`long`	`resetMarkedRecurs(int mask, int[] nrofFiles)` Resets the mark bits of this file and all children (`children()`) which are referred in the FileRemote instance.
`private long`	`resetMarkedRecurs(int mask, int[] nrofFiles, int recursion)` Recursively called method for `resetMarkedRecurs(int, int[])`
`boolean`	`sameDevice(FileRemote other)` Check whether two files are at the same device.
`void`	`search(byte[] search, FileRemoteWalkerCallback callbackUser, FileRemoteProgressEvData timeOrderProgress)` Search in all files.
`static boolean`	`setAccessorSelector(FileRemote.FileRemoteAccessorSelector accessorSelectorP)`
`void`	`setCanonicalAbsPath(java.lang.String pathP)` Sets this as a non-symbolic linked file or dir with the given path.
`void`	`setDirShouldRefresh()`
`void`	`setFileObject(java.lang.Object oFile)`
`boolean`	`setLastModified(long time)`
`long`	`setMarked(int mask)` Marks the file with the given bits in mask.
`int`	`setMarked(int mask, java.lang.Object data)` marks a bit in the `mark`, creates it if it is not existing yet.
`int`	`setNonMarked(int mask, java.lang.Object data)` resets a marker bit in the existing `mark` or does nothing if the bit is not present.
`int`	`setNonMarkedRecursively(int mask, java.lang.Object data)` resets a marker bit in the existing `mark` or does nothing if the bit is not present.
`java.lang.StringBuilder`	`setPathTo(java.lang.StringBuilder ret)` Fills the path to the given StringBuilder and returns the StringBuilder to concatenate.
`void`	`setShouldRefresh()`
`void`	`setSymbolicLinkedPath(java.lang.String pathP)` Sets this as a symbolic linked file or dir with the given path.
`boolean`	`shouldRefresh()`
`FileRemote`	`subdir(java.lang.CharSequence sPathChild)` Gets or creates a child with the given name which is a sub directory of this.
`java.lang.String`	`toString()`
`void`	`walkLocal(FileRemote dstdir, int markSet, int markSetDir, java.lang.String selectFilter, int selectMask, int depthWalk, FileRemoteWalkerCallback callback, FileRemoteCmdEventData cmdDataArg, int cycleProgress, EventWithDst<FileRemoteProgressEvData,?> progressEv)` Walks local only through the FileRemote instances without touch the underlying files on a device.
`void`	`walkRemote(boolean bWait, FileRemote dirDst, int depth, java.lang.String selectFilter, int cycleProgress, EventWithDst<FileRemoteProgressEvData,?> evProgress)` walk file tree with specified callback adequate the concept which is implemented in `FileAccessorLocalJava7` or maybe other file access for embedded control.
`void`	`XXXcopyTo(FileRemote dst, int mode)`

Methods inherited from class java.io.File
compareTo, createTempFile, createTempFile, deleteOnExit, equals, getAbsoluteFile, getCanonicalFile, getFreeSpace, getTotalSpace, getUsableSpace, hashCode, isAbsolute, list, list, listFiles, listRoots, setExecutable, setExecutable, setReadable, setReadable, setReadOnly, setWritable, setWritable, toPath, toURI, toURL

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

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - version
```
public static final java.lang.String version
```
    Version, history and license.
    - 2023-07-24 the CallbackWait was no more used, removed (cleanup), the concept is adequate FileRemoteProgressEventConsumer.
    - 2023-07-19 move and create FileRemoteCmdEventData from the inner class CmdEventData. That causes using FileRemoteCmdEventData.setCmdWalkRemote(FileRemote, org.vishia.fileRemote.FileRemoteCmdEventData.Cmd, FileRemote, String, int, int) etc. instead immediately writing to its variables. Its better to obvious the software goal!
    - 2023-07-19 rename walkRemote(boolean, FileRemote, int, String, int, EventWithDst) from 'walker'
    - 2023-07-18 rename Cmd#walkRefresh from Cmd.walkSelectMark, the name is more concise.
    - 2023-07-18 new #walkLocal(Cmd, FileRemote, int, int, String, int, int, FileRemoteWalkerCallback, FileRemoteCmdEventData, int, EventWithDst) it uses the moved and renewed FileRemoteWalker.
    - 2023-07-17 remove some old stuff for delete, cleanup
    - 2023-07-17 FileRemoteCmdEventData has now private members and getter. It should be used consequently as payload for a remote access. Yet it is obfuscated, it is necessary to know the FileRemote instance while working with. But this is not possible if it is really remote.
    - 2023-04-06 Hartmut chg: copyTo(FileRemote, EventWithDst) and moveTo(String, FileRemote, FileRemoteProgressEvData) now via device.cmd(), the new approach. Used in The.file.Commander
    - 2023-04-02 Hartmut chg: getPathChars() now returns dir path ends with slash. This is in opposite to getPath(), unchanged, defined by File.getPath().
    - 2023-03-15 Hartmut chg: refactoring get(String), getFile(CharSequence, CharSequence), #getDir(String)
    - 2023-02-13 Hartmut chg: #refreshAndMark(int, int, int, String, long, FileRemoteWalkerCallback, FileRemoteProgressEvData) the depths should be unique as first or second argument, todo change the other operations adequate
    - 2023-02-13 Hartmut new: #getDirFileDst(String, FileRemote, String[]) usable for String given dir and mask
    - 2023-01-02 Hartmut chg: fromFile(File) and child(CharSequence, int, int, long, long, long): Generally on creating a FileRemote it should not has any access to the file system, because it is remote. This is now consequently realized. Till now only the PC file system was used, hence one access was usual not obviously. But on access to a non existing network drive, sometimes trouble occur. For The.file.Commander the rule is: Do not access to resources in the graphic thread which are not guaranteed existing. The graphic thread should never be delayed. This is now true (should be true).
    - 2015-09-09 Hartmut bug: It marks too much directories with FileMark.selectSomeInDir, fix: algorithm.
    - 2015-07-04 Hartmut chg: Values of flags mTested, mShouldRefresh, mRefreshChildPending mThreadIsRunning to the highest digit of int, to recognize for manual viewing. That flags should not used in applications. Remove of flags for comparison, the bits are used and defined inside FileMark for a longer time.
    - 2015-05-30 Hartmut new: #copyDirTreeTo(FileRemote, int, String, int, FileRemoteProgressEvData)
    - 2015-05-25 Hartmut new: clusterOfApplication: There is a singleton, the FileCluster is not necessary as argument for fromFile(File) especially to work more simple to use FileRemote capabilities for File operations.
    - 2014-12-20 Hartmut new: #refreshPropertiesAndChildren(CallbackFile) used in Fcmd with an Thread on demand, see org.vishia.fileLocalAccessor.FileAccessorLocalJava7#walkFileTree(FileRemote, boolean, boolean, String, int, int, FileRemoteWalkerCallback) and FileRemoteAccessor.FileWalkerThread.
    - 2014-07-30 Hartmut new: calling FileAccessorLocalJava6#selectLocalFileAlways in getAccessorSelector() for compatibility with Java6. There the existence of java.nio.file.Files is checked, and the File access in Java7 is used if available. So this class runs with Java6 too, which is necessary in some established environments.
    - 2013-10-06 Hartmut new: #getChildren(ChildrenEvent) with aborting a last request.
    - 2013-09-15 Hartmut new: #getChildren(ChildrenEvent) should work proper with Files.walkFileTree(java.nio.file.Path, java.util.Set, int, java.nio.file.FileVisitor). The event should be called back on 300 ms with the gathered files. If the access needs more time, it should be able to have more events to present a part of files, or to abort it. The concept is tested in java-6 yet.
    - 2013-09-15 Hartmut new: Ideas from Java-7 java.nio.Files in the concept of FileRemote: The FileRemote is an instance independent of the file system and stores the file's data. If Java-7 is present, it should be used. But the Java-6 will be held compatible.
    - 2013-08-09 Hartmut chg: The MarkMask_ifc is renamed, all methods setMarked(int) etc. are named 'marked' instead of 'selected'. It is a problem of wording: The instances are only marked, not yet 'selected'. See application of this interface in org.vishia.gral.widget.GralFileSelector: A selected line is the current one or some marked lines.
    - 2013-08-09 Hartmut new: implements MarkMask_ifc for the #cmprResult.
    - 2013-07-29 Hartmut chg: #moveTo(String, FileRemote, CallbackEvent) now have a parameter with file names.
    - 2013-05-24 Hartmut chg: The root will be designated with "/" as sFile
    - 2013-05-24 Hartmut new #cmprResult, setMarked(int)
    - 2013-05-05 Hartmut new isTested()
    - 2013-05-05 Hartmut new mkdir(), mkdirs(), #mkdir(boolean, CallbackEvent), createNewFile(). TODO some operation uses still the super implementation of File. But the super class File should only be used as interface.
    - 2013-05-05 Hartmut chg: child(CharSequence) accepts a path to a sub child. New isChild(CharSequence), isParent(CharSequence).
    - 2013-05-04 Hartmut redesigned ctor and order of elements. sDir does not end with "/" up to now.
    - 2013-04-30 Hartmut new: resetMarkedRecurs(int, int[])
    - 2013-04-29 Hartmut chg: #fromFile(FileCluster, File) has the FileCluster parameter yet, necessary for the concept. This method is not necessary as far as possible because most of Files are a FileRemote instance yet by reference (Fcmd app)
    - 2013-04-28 Hartmut chg: re-engineering check and copy
    - 2013-04-26 Hartmut chg: The constructors of this class should be package private, instead the FileCluster#getFile(String, String) and #child(String) should be used to get an instance of this class. The instances which refers the same file on the file system are existing only one time in the application respectively in the FileRemoteAccessor. In this case additional information can be set to files such as 'selected' or a comparison result. It is in progression.
    - 2013-04-21 Hartmut new: The flags contains bits for #mChecked to mark files as checked with #check(FileRemote, CallbackEvent). With that the check state is able to view.
    - 2013-04-21 Hartmut new: The flags contains bits for #mCmpContent etc. for comparison to view.
    - 2013-04-21 Hartmut new: #copyChecked(CallbackEvent, int) in cohesion with changes in org.vishia.fileLocalAccessor.Copy_FileLocalAcc.
    - 2013-04-12 Hartmut chg: Dedicated attributes for CallbackCmd#successCode etc.
    - 2013-04-07 Hartmut adapt: Event with 2 generic parameter
    - 2013-04-07 Hartmut chg: FileRemote.CallbackEvent contains all the methods to do something with currently copying files, for example CallbackEvent#copyOverwriteFile(int) etc.
    - 2013-03-31 Hartmut chg: Event
    - 2012-11-16 Hartmut chg: Usage of FileRemoteCmdEventData.filesrc and filedst and CallbackEvent#filedst and dst instead EventCmdtypeWithBackEvent#getRefData().
    - 2012-11-11 Hartmut chg: The flag bit mDirectory should be set always, especially also though mTested is false. That should be assured by the FileRemoteAccessor implementation.
    - 2012-10-01 Hartmut chg: children is now of super type File, not FileRemote. Nevertheless FileRemote objects are stored there. Experience is possible to store a File object returned from File.listFiles without wrapping, and replace that with a FileRemote object if necessary. listFiles() returns a File[] like its super method.
    - 2012-10-01 Hartmut new: isTested()
    - 2012-08-11 Hartmut new: method openInputStream(long). An application may need that, for example to create a Reader with the input stream. Some implementations, especially a local file and a ZipFile supports that. An InputStream may force a blocking if data are not available yet for file in a remote device but that may be accepted.
    - 2012-08-11 Hartmut new: listFiles(FileFilter) now implemented here.
    - 2012-08-05 Hartmut chg: The super class File needs the correct path. So it is able to use for a local file nevertheless. What is with oFile if it is a FileRemote? should refer this? See change from 2012-01-01.
    - 2012-08-03 Hartmut chg: Usage of Event in FileRemote. The FileRemoteAccessor.Commission is removed yet. The same instance FileRemote.Callback, now named FileRemote.FileRemoteEvent is used for forward event (commision) and back event.
    - 2012-07-28 Hartmut chg: Concept of remote files enhanced with respect to FileAccessZip.
      
      New references parent and children. They are filled calling #refreshPropertiesAndChildren(CallbackEvent).
      More separation of java.io.File accesses. In the past only the local files were supported really.
      new interface FileRemote.FileRemoteAccessorSelector and setAccessorSelector(FileRemoteAccessorSelector). The user can have any algorithm to select a FileRemoteAccessor depending on the path of the file. A prefix String may determine how the file is to access. If that routine is not called, the FileAccessorLocalJava7.selectLocalFileAlways.
      #FileRemote(FileRemoteAccessor, FileRemote, String, String, long, long, int, Object) has the parent as parameter. The parameter oFileP is stored now. It is any data to access the file object.
      The constructor had access the file if length=-1 was given. But that is not the convention. An access may need execution and waiting time for a remote communication. The constructor should never wait. Instead the methods:
      #refreshProperties(CallbackEvent) and #refreshPropertiesAndChildren(CallbackEvent) have to be called if the properties of the real file on the local system (java.io.File) or any remote system are need. That routines envisages the continuation of working with a callback event are invocation mechanism. For example if the file properties should be shown in a graphic application, the building of the graphic can't stop and wait for more as some 100 milliseconds. It is better to clear a table and continue working in graphic. If the properties are gotten from the remote system then the table will be filled. That may be invoked from another thread, the communication thread for the remote device or by an event mechanism (see FileRemote.CallbackEvent respectively org.vishia.event.EventCmdtypeWithBackEvent.
      The routine fromFile(File) reads are properties of a local file if one is given. In that case the #refreshProperties(CallbackEvent) need not be invoked additionally.
      openRead(long) and openWrite(long) accepts a non-given device. They select it calling FileRemoteAccessorSelector#selectFileRemoteAccessor(String)
      All get methods length, lastModified(), isDirectory() etc. now returns only the stored values. It may necessary to invoke #refreshProperties(CallbackEvent) in the application before they are called to get the correct values. The refreshing can't be called in that getter routines because they should not wait for communication. In the case of local files that access may be shorten in time, but it isn't known whether it is a local file. The user algorithm should work with remote files too if they are tested locally only. Therefore a different strategy to access properties are not proper to use.
      getParentFile() now uses the parent reference. If it is null, a new FileRemote instance for the parent is created, but without access to the file, only with knowledge of the path string. Because the #FileRemote(FileRemoteAccessor, FileRemote, String, String, long, long, int, Object) will be gotten the parent of it too, all parent instances will be set recursively then.
      listFiles() now returns the children only. If the user has not called #refreshPropertiesAndChildren(CallbackEvent), it is empty.
    - 2012-07-21 Hartmut new: #delete(String, boolean, EventCmdtypeWithBackEvent) with given mask. TODO: It should done in FileAccessorLocalJava7 in an extra thread.
    - 2012-03-10 Hartmut new: #chgProps(String, int, int, long, CallbackEvent), #countAllFileLength(CallbackEvent). Enhancements.
    - 2012-02-02 Hartmut chg: Now the sFile (renamed from name) is empty if this describes an directory and it is known that it is an directory. The ctor is adapted therefore. getParent() is changed. Some assertions are set.
    - 2012-02-02 Hartmut chg: Handling of relative paths: It is detected in ctor. TODO relative paths are not tested well.
    - 2012-01-14 Hartmut chg: The toplevel directory contains only one slash in the sDir and an empty name in #key.
    - 2012-01-14 Hartmut new: getParentFile() now implemented here.
    - 2012-01-14 Hartmut new: fromFile(File) to convert from a normal File instance.
    - 2012-01-06 Hartmut new: Some functionality for #_setProperties(long, long, int, Object) and symbolic linked paths.
    - 2012-01-01 Hartmut new: oFile. In the future the superclass File should be used only as interface. TODO: For any file access the oFile-instance should be used by device.
    - 2012-01-01 Hartmut new: #copyTo(FileRemote, EventCmdPingPongType)
    - 2011-12-10 Hartmut creation: It is needed for org.vishia.commander.Fcmd, this tool should work with remote files with any protocol for example FTP. But firstly it is implemented and tested only for local files. The concept is:
      
      All relevant information about a file are stored locally in this instance if they are known.
      If information are unknown, on construction 'unknown' is stored, no access occurs. But if they are requested, an access is done.
      Any instance of the interface FileRemoteAccessor is responsible to execute the remote access.
      The access to local files are done with this class directly.
    Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
    1. You can use this source without any restriction for any desired purpose.
    2. You can redistribute copies of this source to everybody.
    3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
    4. But the LPGL is not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
    5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
    If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
    See Also:
    
    Constant Field Values
  - modeCopyReadOnlyMask
```
public static final int modeCopyReadOnlyMask
```
    See Also:
    
    Constant Field Values
  - modeCopyReadOnlyNever
```
public static final int modeCopyReadOnlyNever
```
    See Also:
    
    Constant Field Values
  - modeCopyReadOnlyOverwrite
```
public static final int modeCopyReadOnlyOverwrite
```
    See Also:
    
    Constant Field Values
  - modeCopyReadOnlyAks
```
public static final int modeCopyReadOnlyAks
```
    See Also:
    
    Constant Field Values
  - modeCopyExistMask
```
public static final int modeCopyExistMask
```
    See Also:
    
    Constant Field Values
  - modeCopyExistNewer
```
public static final int modeCopyExistNewer
```
    See Also:
    
    Constant Field Values
  - modeCopyExistOlder
```
public static final int modeCopyExistOlder
```
    See Also:
    
    Constant Field Values
  - modeCopyExistAll
```
public static final int modeCopyExistAll
```
    See Also:
    
    Constant Field Values
  - modeCopyExistSkip
```
public static final int modeCopyExistSkip
```
    See Also:
    
    Constant Field Values
  - modeCopyExistAsk
```
public static final int modeCopyExistAsk
```
    See Also:
    
    Constant Field Values
  - modeCopyCreateMask
```
public static final int modeCopyCreateMask
```
    See Also:
    
    Constant Field Values
  - modeCopyCreateNever
```
public static final int modeCopyCreateNever
```
    See Also:
    
    Constant Field Values
  - modeCopyCreateYes
```
public static final int modeCopyCreateYes
```
    See Also:
    
    Constant Field Values
  - modeCopyCreateAsk
```
public static final int modeCopyCreateAsk
```
    See Also:
    
    Constant Field Values
  - modeCmprLogNotEqualFiles
```
public static final int modeCmprLogNotEqualFiles
```
    Bits for the logging mode of #cmprDirs(File, File, String, List).
    
    See Also:
    
    Constant Field Values
  - modeCmprLogMissing2File
```
public static final int modeCmprLogMissing2File
```
    Bits for the logging mode of #cmprDirs(File, File, String, List).
    
    See Also:
    
    Constant Field Values
  - modeCmprLogMissing1File
```
public static final int modeCmprLogMissing1File
```
    Bits for the logging mode of #cmprDirs(File, File, String, List).
    
    See Also:
    
    Constant Field Values
  - modeCmprLogComparedFiles
```
public static final int modeCmprLogComparedFiles
```
    Bits for the logging mode of #cmprDirs(File, File, String, List).
    
    See Also:
    
    Constant Field Values
  - mExist
```
public static final int mExist
```
    Info about the file stored in flags returned with getFlags().
    
    See Also:
    
    Constant Field Values
  - mCanRead
```
public static final int mCanRead
```
    Info about the file stored in flags returned with getFlags().
    
    See Also:
    
    Constant Field Values
  - mCanWrite
```
public static final int mCanWrite
```
    Info about the file stored in flags returned with getFlags().
    
    See Also:
    
    Constant Field Values
  - mHidden
```
public static final int mHidden
```
    Info about the file stored in flags returned with getFlags().
    
    See Also:
    
    Constant Field Values
  - mDirectory
```
public static final int mDirectory
```
    Info whether the File is a directory. This flag-bit should be present always independent of the mTested flag bit.
    
    See Also:
    
    Constant Field Values
  - mFile
```
public static final int mFile
```
    Info whether the File is a directory. This flag-bit should be present always independent of the mTested flag bit.
    
    See Also:
    
    Constant Field Values
  - mExecute
```
public static final int mExecute
```
    Info whether it is an executable (executable flag on unix)
    
    See Also:
    
    Constant Field Values
  - mExecuteAny
```
public static final int mExecuteAny
```
    Info whether it is an executable (executable flag on unix)
    
    See Also:
    
    Constant Field Values
  - mRelativePath
```
public static final int mRelativePath
```
    Type of given path.
    
    See Also:
    
    Constant Field Values
  - mAbsPath
```
public static final int mAbsPath
```
    Type of given path.
    
    See Also:
    
    Constant Field Values
  - mSymLinkedPath
```
public static final int mSymLinkedPath
```
    A symbolic link in unix.
    
    See Also:
    
    Constant Field Values
  - mCanReadGrp
```
public static final int mCanReadGrp
```
    Group and any read and write permissions.
    
    See Also:
    
    Constant Field Values
  - mCanWriteGrp
```
public static final int mCanWriteGrp
```
    Group and any read and write permissions.
    
    See Also:
    
    Constant Field Values
  - mExecuteGrp
```
public static final int mExecuteGrp
```
    Group and any read and write permissions.
    
    See Also:
    
    Constant Field Values
  - mCanReadAny
```
public static final int mCanReadAny
```
    Group and any read and write permissions.
    
    See Also:
    
    Constant Field Values
  - mCanWriteAny
```
public static final int mCanWriteAny
```
    Group and any read and write permissions.
    
    See Also:
    
    Constant Field Values
  - mRoot
```
public static final int mRoot
```
    Set if it is a root directory. The mDirectory is set too.
    
    See Also:
    
    Constant Field Values
  - mShouldRefresh
```
public static final int mShouldRefresh
```
    Flags as result of an comparison: the other file exist but its content is different. See
    
    See Also:
    
    Constant Field Values
  - mThreadIsRunning
```
public static final int mThreadIsRunning
```
    Set if a thread runs to get file properties.
    
    See Also:
    
    Constant Field Values
  - mRefreshChildPending
```
public static final int mRefreshChildPending
```
    Set if the file is removed yet because a refresh is pending. Note that the FileRemote instance should be kept for marking etc.
    
    See Also:
    
    Constant Field Values
  - mTested
```
public static final int mTested
```
    Set if the file is tested physically. If this bit is not set, all other flags are not representable and the file may be only any path without respect to an existing file.
    
    See Also:
    
    Constant Field Values
  - accessorSelector
```
private static FileRemote.FileRemoteAccessorSelector accessorSelector
```
    Instance of the application-width selector for FileRemoteAccessor.
  - ctIdent
```
private static int ctIdent
```
    Counter, any instance has an ident number.
  - _ident
```
private final int _ident
```
    A indent number, Primarily for debug and test.
  - clusterOfApplication
```
public static final FileCluster clusterOfApplication
```
    This cluster is used if a specific cluster should not be used. It is the standard cluster. With null as argument for the FileCluster, this cluster is used.
  - itsCluster
```
public final FileCluster itsCluster
```
    Any FileRemote instance should be member of a FileCluster. Files in the cluster can be located on several devices. But they are selected commonly.
  - device
```
protected FileRemoteAccessor device
```
    The device which manages the physical files. For the local file system the FileAccessorLocalJava7 is used.
  - mark
```
protected FileMark mark
```
    A mark and count instance for this file. It is null if it is not necessary.
  - timeRefresh
```
public long timeRefresh
```
    The last time where the file was synchronized with its physical properties.
  - timeChildren
```
public long timeChildren
```
    The last time where the file was synchronized with its physical properties.
  - sDir
```
protected java.lang.String sDir
```
    The directory path of the file. It does not end with "/" The directory path is absolute and normalized. It doesn't contain any "/./" or "/../"-parts.
    This absolute path can contain a start string for a remote device designation respectively the drive designation for MS-Windows.
    If the instance is the root, this element contains an empty String in UNIX systems, the "C:" drive in Windows or a special remote designation before the first slash in the path.
  - sFile
```
protected java.lang.String sFile
```
    The name with extension of the file or directory name. If this instance is the root, this element contains "/". Note: It is not final because the name may be varied in upper or lower case on Windows file system. It is possible that first the file is defined in other case writing, then corrected on refresh.
  - sCanonicalPath
```
protected java.lang.String sCanonicalPath
```
    The unique path to the file or directory entry. If the file is symbolic linked (on UNIX systems), this field contains the non-linked direct path. But the sDir contains the linked path.
  - date
```
protected long date
```
    Timestamp of the file.
  - dateCreation
```
protected long dateCreation
```
    Timestamp of the file.
  - dateLastAccess
```
protected long dateLastAccess
```
    Timestamp of the file.
  - length
```
protected long length
```
    Length of the file.
  - flags
```
protected int flags
```
    Some flag bits. See constants mExist etc.
  - parent
```
FileRemote parent
```
    The parent instance, it is the directory where the file is member of. This reference may be null if the parent instance is not used up to now. If it is filled, it is persistent.
  - children
```
private java.util.Map<java.lang.String,FileRemote> children
```
    The content of a directory. It contains all files, proper for return listFiles() without filter. The content is valid at the time of calling refreshPropertiesAndChildren(boolean, EventWithDst) or its adequate. It is possible that the content of the physical directory is changed meanwhile. If this field should be returned without null, especially on listFiles() and the file is a directory, the {@link #refreshPropertiesAndChildren(boolean, EventWithDst)
  - oFile
```
java.lang.Object oFile
```
    This is the internal file object. It is handled by the device only.
  - path
```
protected java.nio.file.Path path
```
    can be null or set with the valid path. It is the concept using java.nio.file. Note: This element hides the File#path of the super class which is final and private. It should not confuse the user.
  - evSrc
```
EventSource evSrc
```
  - acc_
```
private final FileRemote.InternalAccess acc_
```
- Constructor Detail
  - FileRemote
```
protected FileRemote(FileCluster cluster,
                     FileRemoteAccessor device,
                     FileRemote parent,
                     java.lang.CharSequence sPath,
                     long length,
                     long dateLastModified,
                     long dateCreation,
                     long dateLastAccess,
                     int flags,
                     java.lang.Object oFileP,
                     boolean OnlySpecialCall)
```
    Constructs an instance. The constructor is protected because only special methods constructs an instance in knowledge of existing instances in FileCluster.
    
    This invocation does not force any access to the file system. The parameter may be given by a complete communication or file access before construction of this. Then they are given as parameter for this constructor.
    
    The parameter of the file (properties, length, date) can be given as 'undefined' using the 0 as value. Then the quest exists() returns false. This instance describes a File object only, it does not access to the file system. The properties of the real file inclusively the length and date can be gotten from the file system calling #refreshProperties(CallbackEvent). This operation may be invoked in another thread (depending on the device) and may be need some operation time.
    
    Parameters:
    
    cluster - null, then use clusterOfApplication, elsewhere the special cluster where the file is member of. It can be null if the parent is given, then the cluster of the parent is used. It have to be matching to the parent. It do not be null if a parent is not given. A cluster can be created in an application invoking the constructor FileCluster.FileCluster().
    
    device - The device which organizes the access to the file system. It may be null, then the device will be gotten from the parent or from the sDirP.
    
    parent - The parent file if known or null. If it is null, the sDirP have to be given with the complete absolute path. If parent is given, this file will be added to the parent as child.
    
    sPath - The path to the directory. If the parent file is given, either it have to be match to or it should be null. The standard path separator is the slash "/". A backslash will be converted to slash internally, it isn't distinct from the slash. If this parameter ends with an slash or backslash and the name is null or empty, this is designated as an directory descriptor. mDirectory will be set in flags.
    
    length - The length of the file. Maybe 0 if unknown.
    
    date - Timestamp of the file. Maybe 0 if unknown.
    
    flags - Properties of the file. Maybe 0 if unknown.
    
    oFileP - an system file Object, may be null.
    
    OnlySpecialCall -
- Method Detail
  - path
```
public java.nio.file.Path path()
```
  - file
```
public java.io.File file()
```
  - child
```
public FileRemote child(java.lang.CharSequence sPathChild)
```
    Gets or creates a child with the given name. If the child is not existing, it is create as a new FileRemote instance which is not tested. The created instances is not registered in the itsCluster because it is assumed that it is a file, not a directory. But all created sub directories of a given local path are registered.
    
    Parameters:
    
    sPathChild - Name or relative pathname of the child. It can be contain "/" or "\", if more as one level of child should be created. If it has a '/' on end it is created as a sub directory and registered in its itsCluster.
    
    Returns:
    
    The child, not null.
  - subdir
```
public FileRemote subdir(java.lang.CharSequence sPathChild)
```
    Gets or creates a child with the given name which is a sub directory of this. If the directory is not existing, it is create as a new FileRemote instance which is not tested. The created instances is registered in the itsCluster.
    
    Parameters:
    
    sPathChild - Name or relative pathname of the child. It can be contain "/" or "\", if more as one level of child should be created. It may have a '/' on end or not.
    
    Returns:
    
    The child, not null.
  - child
```
private FileRemote child(java.lang.CharSequence sPathChild,
                         int flags,
                         int length,
                         long dateLastModified,
                         long dateCreation,
                         long dateLastAccess)
```
    Returns the instance of FileRemote which is the child of this. If the child does not exists it is created and added as child. That is independent of the existence of the file on the file system. A non existing child is possible, it may be created on file system later.
    
    All created sub directories are registered in itsCluster
    TODO: test if the path mets a file but the path is not on its end. Then it may be a IllegalArgumentException.
    
    Parameters:
    
    sName - Name of the child or a local path from this to a deeper sub child. If the name ends with a slash or backslash, the returned instance will be created as sub directory.
    
    Returns:
    
    The child instance.
  - getChild
```
public FileRemote getChild(java.lang.CharSequence name)
```
  - children
```
public java.util.Map<java.lang.String,FileRemote> children()
```
    Gets the Index of the children sorted by name.
    
    Returns:
  - cleanChildren
```
public void cleanChildren()
```
    Cleans the children list. The children should be refreshed from the file system.
  - createChildrenList
```
public static java.util.Map<java.lang.String,FileRemote> createChildrenList()
```
    Method to create a children list. Firstly a java.util.TreeMap was used for that. But a IndexMultiTable is better, because the sorted list is better able to view in debugger.
    
    Returns:
    
    An instance of Map to store children FileRemote sorted by its filename.
  - setAccessorSelector
```
public static boolean setAccessorSelector(FileRemote.FileRemoteAccessorSelector accessorSelectorP)
```
  - getAccessorSelector
```
public static FileRemote.FileRemoteAccessorSelector getAccessorSelector()
```
  - fromFile
```
public static FileRemote fromFile(java.io.File src)
```
    Returns a FileRemote instance from a standard java.io.File instance. If src is instanceof FileRemote already, it returns src. Elsewhere it builds a new instance of FileRemote which inherits from File, it is a new instance of File too.
    
    Parameters:
    
    src - Any File or FileRemote instance.
    
    Returns:
    
    src if it is instance of FileRemote or a new Instance within the clusterOfApplication.
  - get
```
public static FileRemote get(FileCluster cluster,
                             java.lang.String filePath)
```
  - get
```
public static FileRemote get(java.lang.String filePath)
```
    Gets an existing FileRemote instance or creates a new one.
    
    Parameters:
    
    filePath - if ends with "/" then gets or creates a directory.
    
    Returns:
  - getDir
```
public static FileRemote getDir(FileCluster cluster,
                                java.lang.CharSequence dirPath)
```
    Returns the instance which is associated to the given directory.
    
    Parameters:
    
    cluster - the cluster where the dir should be searched
    
    dirPath - The directory path where the file is located, given absolute.
    
    Returns:
    
    A existing or new instance.
  - getDir
```
public static FileRemote getDir(java.lang.CharSequence dirPath)
```
    Returns the instance which is associated to the given directory.
    
    Parameters:
    
    dirPath - The directory path where the file is located, given absolute.
    
    Returns:
    
    A existing or new instance.
  - getFile
```
public static FileRemote getFile(FileCluster cluster,
                                 java.lang.CharSequence dirPath,
                                 java.lang.CharSequence name)
```
    Returns the instance which is associated to the given directory and the file in this directory.
    
    Parameters:
    
    dirPath - The directory path where the file is located,
    
    name - The name of the file.
    
    Returns:
    
    A existing or new instance.
  - getFile
```
public static FileRemote getFile(java.lang.CharSequence dir,
                                 java.lang.CharSequence name)
```
    Returns the instance which is associated to the given directory and name.
    
    Parameters:
    
    dir - The directory path where the file is located, given absolute.
    
    name - The name of the file.
    
    Returns:
    
    A existing or new instance.
  - device
```
public FileRemoteAccessor device()
```
  - putNewChild
```
void putNewChild(FileRemote child)
```
  - setShouldRefresh
```
public void setShouldRefresh()
```
  - setDirShouldRefresh
```
public void setDirShouldRefresh()
```
  - shouldRefresh
```
public boolean shouldRefresh()
```
  - setMarked
```
public long setMarked(int mask)
```
    Marks the file with the given bits in mask.
    
    Parameters:
    
    mask -
    
    Returns:
    
    number of Bytes (file length)
  - resetMarked
```
public long resetMarked(int mask)
```
    Resets the mark bits of this file.
    
    Parameters:
    
    mask - Mask to reset bits.
    
    Returns:
    
    number of Bytes (file length)
  - resetMarkedRecurs
```
public long resetMarkedRecurs(int mask,
                              int[] nrofFiles)
```
    Resets the mark bits of this file and all children (children()) which are referred in the FileRemote instance. This method does not access the files on the file system. It works only with the FileRemote instances.
    
    Parameters:
    
    bit - mask Mask to reset mark bits.
    
    nrofFiles - Output reference, will be incremented for all files which's mark are reseted. Maybe null, then unused.
    
    Returns:
    
    Sum of all bytes (file length) of the reseted files.
  - resetMarkedRecurs
```
private long resetMarkedRecurs(int mask,
                               int[] nrofFiles,
                               int recursion)
```
    Recursively called method for resetMarkedRecurs(int, int[])
    
    Parameters:
    
    mask -
    
    nrofFiles -
    
    recursion -
    
    Returns:
  - getCreateMark
```
public FileMark getCreateMark()
```
    Gets or creates a FileMark for this file.
    
    Returns:
  - mark
```
public FileMark mark()
```
    Gets the FileMark for this file or null if not marked in any kind.
    
    Returns:
  - getMark
```
public int getMark()
```
    Returns the mark of a mark or 0 if it is not present.
    
    Specified by:
    
    getMark in interface MarkMask_ifc
    
    Returns:
    
    bits of selection, 0 if it is not selected.
    
    See Also:
    
    MarkMask_ifc.getMark()
  - setNonMarked
```
public int setNonMarked(int mask,
                        java.lang.Object data)
```
    resets a marker bit in the existing mark or does nothing if the bit is not present.
    
    Specified by:
    
    setNonMarked in interface MarkMask_ifc
    
    Parameters:
    
    mask - The bit which presents the source.
    
    Returns:
    
    The mark bits before this action is done.
    
    See Also:
    
    MarkMask_ifc.setNonMarked(int, java.lang.Object)
  - setNonMarkedRecursively
```
public int setNonMarkedRecursively(int mask,
                                   java.lang.Object data)
```
    resets a marker bit in the existing mark or does nothing if the bit is not present.
    
    See Also:
    
    MarkMask_ifc.setNonMarked(int, java.lang.Object)
  - setMarked
```
public int setMarked(int mask,
                     java.lang.Object data)
```
    marks a bit in the mark, creates it if it is not existing yet.
    
    Specified by:
    
    setMarked in interface MarkMask_ifc
    
    Parameters:
    
    mask - The bit which presents the source.
    
    Returns:
    
    The mark bits before this action is done. If it is 0, this source is the only one which has marks the object.
    
    See Also:
    
    MarkMask_ifc.setMarked(int, java.lang.Object)
  - isMarked
```
public boolean isMarked(int mask)
```
  - _setProperties
```
public void _setProperties(long length,
                           long date,
                           long dateCreation,
                           long dateAccess,
                           int flags,
                           java.lang.Object oFileP)
```
    Sets the properties to this. This method is not intent to invoke from a users application. It should only invoked by the FileRemoteAccessor implementation to set properties of this file. Only because the FileRemoteAccessor implementation may be organized in another package, it should be public.
    
    Parameters:
    
    length -
    
    date -
    
    flags -
    
    oFileP - reference to a file Object, for example java.io.File for local files.
  - refreshProperties
```
public void refreshProperties(EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Gets the properties of the file from the physical file.
    
    Parameters:
    
    callback - if null gets the properties immediately in this thread.
  - cmdRemote
```
public void cmdRemote(FileRemoteCmdEventData.Cmd cmd,
                      FileRemote dstdir,
                      java.lang.String selectFilter,
                      int cycleProgress,
                      int depthWalk,
                      FileRemoteCmdEventData cmdDataArg,
                      EventWithDst<FileRemoteProgressEvData,?> progressEv)
```
    This is the basic operation to force execution with this file or dir either on another device or in another thread, depending on its device(). It uses the FileRemoteAccessor.cmd(boolean, FileRemoteCmdEventData, EventWithDst) for access, it's only a wrapper. But the device() is clarified before.
    
    Parameters:
    
    cmd - one of the admissible commands for this argument set, all commands which should be executable in a remote device.
    
    dstdir - if necessary a destination, null if cmd does not need a destination
    
    selectFilter - to select files and dirs per name.
    
    cycleProgress - 0 = progressEv for any file action, else time in ms for progress feedback
    
    depthWalk - 0 any deepness, 1 = one child level
    
    cmdDataArg - If null then create temporary instance internally, else reuse it
    
    progressEv - event for back information to inform about progress and success. null then execution is done in the own thread if possible in the own device (local file system). If it should be executed really on a remote device, then null = no feedback. Else use of this event instance for feedback and done. Use EventConsumerAwait.awaitExecution(long, boolean) for done information. The EventConsumer is the instance used as destination for EventWithDst.EventWithDst(String, EventSource, EventConsumer, org.vishia.event.EventThread_ifc, Payload). The instances for the progressEv and its consumer can be created and used persistently. Note that EventWithDst.cleanData() should be invoked before call this operation.
  - walkLocal
```
public void walkLocal(FileRemote dstdir,
                      int markSet,
                      int markSetDir,
                      java.lang.String selectFilter,
                      int selectMask,
                      int depthWalk,
                      FileRemoteWalkerCallback callback,
                      FileRemoteCmdEventData cmdDataArg,
                      int cycleProgress,
                      EventWithDst<FileRemoteProgressEvData,?> progressEv)
```
    Walks local only through the FileRemote instances without touch the underlying files on a device. It may be that the FileRemote tree is updated (synchronized with the File system) or not. It deals with the current state. For the selected files and dirs the callback is executed. The callback can deal especially with the underlying file system.
    
    Parameters:
    
    dstdir - a possible destination FileRemote instance, maybe used in callback.
    
    markSet - this bits are set or reset to all selected files. Note: FileMark.resetMark determines set or reset.
    
    markSetDir - this bits are set or reset to all selected directories. Note: FileMark.resetMark determines set or reset.
    
    selectFilter - given file filter due to FilepathFilterM
    
    selectMask - mask for selection dir or files. Note: it is possible to reset exact this bits with markSet and markSetDir
    
    depthWalk - 0: walk through full deepness, 1: only the first level after this src directory.
    
    callback - execute the callback for any selected dir or file.
    
    cmdDataArg - if not null then this instance is reused as data for walking.
    
    cycleProgress - <0 then do not use an extra thread. 1: event for any selected file and dir for feedback. >1: time in ms for feedback in a suitable time.
    
    progressEv - if not null then this event is processed for any file or dir or after cycleProcess ms. For any file and dir the number of files and the sum of bytes are count.
  - walkRemote
```
public void walkRemote(boolean bWait,
                       FileRemote dirDst,
                       int depth,
                       java.lang.String selectFilter,
                       int cycleProgress,
                       EventWithDst<FileRemoteProgressEvData,?> evProgress)
```
    walk file tree with specified callback adequate the concept which is implemented in FileAccessorLocalJava7 or maybe other file access for embedded control. All arguments are set to an instance of FileRemoteCmdEventData, with them device FileRemoteAccessor.cmd(boolean, FileRemoteCmdEventData, EventWithDst) is called.
    
    Parameters:
    
    bWait - true then executes the walker in this thread, false then use an extra thread.
    
    dirDst - can be used by the callback
    
    depth - depth to walk,
    
    markSet - Bits to mark files while walking through
    
    markSetDir - Bits to mark directories while walking through
    
    selectFilter - Wildcard mask to select source files. Maybe empty or null, then all files are used.
    
    selectMark - Bits to select from mark maybe manually set before or via other algorithm It can use some specific bits: FileMark.orWithSelectString, FileMark.ignoreSymbolicLinks
    
    callback - null possible. A callback operation set for each file and dir. This defines what to do with the files.
    
    cycleProgress - cycle for progress in ms, 0 means progress for any file.
    
    evProgress - for progress. If bWait is false and evBack is null, no answer is given.
  - refreshProperties
```
public void refreshProperties()
```
    Gets the properties of the file from the physical file immediately in this thread.
  - refreshPropertiesAndChildren
```
public void refreshPropertiesAndChildren(boolean bWait,
                                         EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Refreshes the properties of this file and gets all children in an extra thread with user-callback for any file. In an on demand created thread the routine FileRemoteAccessor#refreshPropertiesAndChildren(FileRemote, boolean, FileFilter, CallbackFile) will be called with the given CallbackFile.
    
    Parameters:
    
    callback - maybe null if the callback is not used.
    
    bWait - true then waits for success. On return the walk through is finished and all callback routines are invoked already. false then this method may return immediately. The callback routines are not invoked. The walk is done in another thread. Note: Whether or not another thread is used for communication it is not defined with them. It is possible to start another thread and wait for success, for example if communication with a remote device is necessary.
  - refreshAndMark
```
public void refreshAndMark(boolean bWait,
                           int depth,
                           int setMark,
                           int setMarkDir,
                           java.lang.String sMaskSelection,
                           long markSelection,
                           FileRemoteWalkerCallback callbackUser,
                           EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Refreshes a file tree and mark some files. This routine creates another thread usually, which accesses the file system and invokes the callback routines. A longer access time does not influence this thread. The result is given only if the FileRemoteWalkerCallback#finished(FileRemote, org.vishia.util.SortedTreeWalkerCallback.Counters) will be invoked.
    
    Parameters:
    
    depth - deepness to entry in the directory tree. Use 0 if all levels should enter.
    
    setMark - bits to set in the mark() SelectMask.selectMask for the selected files If FileMark.resetMark is set, the bits given in this field will be set to 0.
    
    setMarkDir - bits to set in the mark() for the directories containing selected files If FileMark.resetMark is set, the bits given in this field will be set to 0.
    
    sMaskSelection - file selection mask due to FilepathFilterM for files using the device FileAccessorLocalJava7 or any other proper select string for other devices.
    
    markSelection - Bits to select with mark bits. If FileMark.orWithSelectString is set, this is a OR relation, elsewhere AND with the select string. OR relation means, a file is selected either with the sMaskSelection or with one of this bits. AND relation means, one of this bits should be set, and the sMaskSelection should be matching.
    
    callbackUser - a user instance which will be informed on start, any file, any directory and the finish.
    
    progressCopyDirTreeWithCallback - instance for callback.
  - refreshAndSearch
```
public void refreshAndSearch(int depth,
                             java.lang.String mask,
                             int mark,
                             byte[] search,
                             FileRemoteWalkerCallback callbackUser,
                             EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Refreshes a file tree and search in some or all files. This routine creates another thread usually which accesses the file system and invokes the callback routines. A longer access time does not influence this thread. The result is given only if the FileRemoteWalkerCallback#finished(FileRemote, org.vishia.util.SortedTreeWalkerCallback.Counters) will be invoked.
    
    Parameters:
    
    depth - at least 1 for enter in the first directory. Use 0 if all levels should entered.
    
    mask - a mask to select directory and files
    
    bits - to select files by its mark, 0 then select all (ignore mark)
    
    callbackUser - maybe null, a user instance which will be informed on start, any file, any directory and the finish.
    
    timeOrderProgress - maybe null, if given then this callback is informed on any file or directory.
  - cmprDirTreeTo
```
public void cmprDirTreeTo(boolean bWait,
                          FileRemote dir2,
                          java.lang.String mask,
                          EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Refreshes a file tree and compare some or all files. This routine creates another thread usually which accesses the file system and invokes the callback routines. A longer access time does not influence this thread. The result is given only if the FileRemoteWalkerCallback#finished(FileRemote, org.vishia.util.SortedTreeWalkerCallback.Counters) will be invoked.
    
    Parameters:
    
    depth - at least 1 for enter in the first directory. Use 0 if all levels should entered.
    
    mask - a mask to select directory and files
    
    bits - to select files by its mark, 0 then select all (ignore mark)
    
    callbackUser - maybe null, a user instance which will be informed on start, any file, any directory and the finish.
    
    timeOrderProgress - maybe null, if given then this callback is informed on any file or directory.
  - copyDirTreeTo
```
public void copyDirTreeTo(boolean bWait,
                          FileRemote dirDst,
                          int depth,
                          java.lang.String mask,
                          EventWithDst<FileRemoteProgressEvData,?> evBack)
```
  - copyDirTreeTo
```
public void copyDirTreeTo(boolean bWait,
                          FileRemote dirDst,
                          int depth,
                          int markSet,
                          int markSetDir,
                          java.lang.String selectFilter,
                          int selectMask,
                          EventWithDst<FileRemoteProgressEvData,?> evBack)
```
  - deleteFilesDirTree
```
public void deleteFilesDirTree(boolean bWait,
                               int depth,
                               java.lang.String mask,
                               EventWithDst<FileRemoteProgressEvData,?> evBack)
```
  - copyTo
```
public java.lang.String copyTo(FileRemote dst,
                               EventWithDst<FileRemoteProgressEvData,?> evBack)
```
  - renameTo
```
public java.lang.String renameTo(FileRemote dst,
                                 EventWithDst<FileRemoteProgressEvData,?> evBack)
```
  - renameTo
```
public boolean renameTo(java.io.File dst)
```
    renames or moves this file to the given path in dst. This is the alternative implementation against File.renameTo(File) which is not used. The File dst should be either a FileRemote instance, or it is converted to it for temporary usage.
    
    Overrides:
    
    renameTo in class java.io.File
  - setSymbolicLinkedPath
```
public void setSymbolicLinkedPath(java.lang.String pathP)
```
    Sets this as a symbolic linked file or dir with the given path. This method is not intent to invoke from a users application. It should only invoked by the FileRemoteAccessor implementation to set properties of this file. Only because the FileRemoteAccessor implementation may be organized in another package, it should be public.
    
    Parameters:
    
    pathP - The path where the file is organized.
  - setCanonicalAbsPath
```
public void setCanonicalAbsPath(java.lang.String pathP)
```
    Sets this as a non-symbolic linked file or dir with the given path. This method is not intent to invoke from a users application. It should only invoked by the FileRemoteAccessor implementation to set properties of this file. Only because the FileRemoteAccessor implementation may be organized in another package, it should be public.
    
    Parameters:
    
    pathP - The absolute canonical path where the file is organized.
  - sameDevice
```
public boolean sameDevice(FileRemote other)
```
    Check whether two files are at the same device. It means it can be copied, compared etc. remotely.
    
    Parameters:
    
    other - The other file to check
    
    Returns:
    
    true if they are at the same device. The same device is given if the comparison of the FileRemoteAccessor instances of both files using device.equals(other.device) returns true.
  - openRead
```
public java.nio.channels.ReadableByteChannel openRead(long passPhrase)
```
    Opens a read access to this file. If the file is remote, this method should return immediately with a prepared channel functionality (depending from implementation). A communication with the remote device will be initiated to get the first bytes parallel in an extra thread. If the first access will be done, that bytes will be returned without waiting. If a non-blocking mode is used for the device, a ReadableByteChannel.read(java.nio.ByteBuffer) invocation returns 0 if there are no bytes available in this moment. An polling invocation later may transfer that bytes. In this kind a non blocking mode is possible.
    
    Parameters:
    
    passPhrase - a pass phrase if the access is secured.
    
    Returns:
    
    The channel to access.
  - openInputStream
```
public java.io.InputStream openInputStream(long passPhrase)
```
    Opens a read access to this file. If the file is remote, this method should return immediately with a prepared stream functionality (depending from implementation). A communication with the remote device will be initiated to get the first bytes parallel in an extra thread. If the first access will be done, that bytes will be returned without waiting. But if the data are not supplied in this time, the InputStream.read() method blocks until data are available or the end of file or any error is detected. That is the contract for a InputStream.
    
    Parameters:
    
    passPhrase - a pass phrase if the access is secured.
    
    Returns:
    
    The byte input stream to access.
  - openOutputStream
```
public java.io.OutputStream openOutputStream(long passPhrase)
```
    Opens a write access to this file. If the file is remote, this method should return immediately with a prepared stream functionality (depending from implementation). A communication with the remote device will be initiated to write.
    
    Parameters:
    
    passPhrase - a pass phrase if the access is secured.
    
    Returns:
    
    The byte input stream to access.
  - openWrite
```
public java.nio.channels.WritableByteChannel openWrite(long passPhrase)
```
    Opens a write access to this file.
    
    Parameters:
    
    passPhrase - a pass phrase if the access is secured.
    
    Returns:
    
    The channel to access.
  - length
```
public long length()
```
    Overrides:
    
    length in class java.io.File
  - lastModified
```
public long lastModified()
```
    Overrides:
    
    lastModified in class java.io.File
  - creationTime
```
public long creationTime()
```
    Returns the creation time of the file if the file system supports it. Elsewhere returns 0.
  - lastAccessTime
```
public long lastAccessTime()
```
    Returns the last access time of the file if the file system supports it. Elsewhere returns 0.
  - setLastModified
```
public boolean setLastModified(long time)
```
    Overrides:
    
    setLastModified in class java.io.File
  - oFile
```
public java.lang.Object oFile()
```
  - setFileObject
```
public void setFileObject(java.lang.Object oFile)
```
  - getFlags
```
public int getFlags()
```
  - getName
```
public java.lang.String getName()
```
    Specified by:
    
    getName in interface TreeNodeNamed_ifc
    
    Overrides:
    
    getName in class java.io.File
  - getParent
```
public java.lang.String getParent()
```
    Returns the parent path, it is the directory path. It is define by:
    
    Overrides:
    
    getParent in class java.io.File
    
    Returns:
    
    path without ending slash.
    
    See Also:
    
    File.getParent()
  - getPath
```
public java.lang.String getPath()
```
    Gets the path of the file. For this class the path should be esteemed as canonical, it is considered on constructor. The difference between this routine and getCanonicalPath() is: The canonical path under Unix-Systems (linux) is the linked path. The return path of this routine is the path without dissolving symbolic links.
    
    Overrides:
    
    getPath in class java.io.File
    
    Returns:
    
    path never ending with "/", but canonical, slash as separator.
  - getPathChars
```
public java.lang.CharSequence getPathChars()
```
    Returns the same as getPath() for files, but ends with '/' if this is a directory. It is very sensible and useful to dedicate a path to an existing directory with ending '/'. It does not build a String from a new StringBuilder.
    
    Returns:
    
    The path to the file.
  - getDirChars
```
public java.lang.CharSequence getDirChars()
```
  - setPathTo
```
public java.lang.StringBuilder setPathTo(java.lang.StringBuilder ret)
```
    Fills the path to the given StringBuilder and returns the StringBuilder to concatenate. This method helps to build a path with this FileRemote and maybe other String elements with low effort of memory allocation and copying.
    
    Returns:
    
    ret itself cleaned and filled with the path to the file.
  - getCanonicalPath
```
public java.lang.String getCanonicalPath()
```
    Overrides:
    
    getCanonicalPath in class java.io.File
  - isChild
```
public java.lang.CharSequence isChild(java.lang.CharSequence path)
```
    Checks whether the given path describes a child (any deepness) of this file and returns the normalized child string.
    
    Parameters:
    
    path - Any path may contain /../
    
    Returns:
    
    null if path does not describe a child of this. The normalized child path from this directory path if it is a child.
  - isParent
```
public java.lang.CharSequence isParent(java.lang.CharSequence path)
```
    Checks whether the given path describes a parent (any deepness) of this file and returns the normalized child string.
    
    Parameters:
    
    path - Any path may contain /../
    
    Returns:
    
    null if path does not describe a parent of this. The normalized parent path if it is a parent.
  - getParentFile
```
public FileRemote getParentFile()
```
    Gets the parent directory. It creates a new instance of FileRemote with the path infos from sDir.
    
    Overrides:
    
    getParentFile in class java.io.File
    
    Returns:
    
    null if this is the toplevel directory.
  - isTested
```
public boolean isTested()
```
    Returns true if the file was tested in the past. Returns false only if the file is created and never refreshed.
  - isTested
```
public boolean isTested(long since)
```
    Returns true if the last time of refreshing is newer than since.
    
    Parameters:
    
    since - A milliseconds after 1970
    
    Returns:
    
    true if may actual.
  - exists
```
public boolean exists()
```
    Returns true if the file seems to be existing. If the FileRemote instance was never refreshed with the physical file system, the #refreshProperties(CallbackEvent) is called yet. But if the file was refreshed already, the existing flag is returned only. To assure that the existing of the file is correct, call #refreshProperties(CallbackEvent) before this call on a proper time. Note that an invocation of File.exists() may have the same problem. The file may exist in the time of this call, but it may not exist ever more in the future if the application will deal with it. Usage of a file for opening a reader or writer without Exception is the only one assurance whether the file exists really. Note that a deletion of an opened file will be prevent from the operation system.
    
    Overrides:
    
    exists in class java.io.File
    
    See Also:
    
    File.exists()
  - isFile
```
public boolean isFile()
```
    TODO mFile is not set yet, use !isDirectory 2015-01-09
    
    Overrides:
    
    isFile in class java.io.File
    
    See Also:
    
    File.isFile()
  - isHidden
```
public boolean isHidden()
```
    TODO mFile is not set yet, use !isDirectory 2015-01-09
    
    Overrides:
    
    isHidden in class java.io.File
    
    See Also:
    
    File.isFile()
  - isDirectory
```
public boolean isDirectory()
```
    Returns true if the FileRemote instance was created as directory or if any #refreshProperties(CallbackEvent) call before this call has detected that it is an directory.
    
    Overrides:
    
    isDirectory in class java.io.File
    
    See Also:
    
    File.isDirectory()
  - isRoot
```
public boolean isRoot()
```
  - canWrite
```
public boolean canWrite()
```
    true if due to Java orientation to the file system the file is not read only. it follows File.canWrite()
    
    Overrides:
    
    canWrite in class java.io.File
  - canRead
```
public boolean canRead()
```
    true if due to Java orientation to the file system the file is readable (visible). it follows File.canRead()
    
    Overrides:
    
    canRead in class java.io.File
  - canExecute
```
public boolean canExecute()
```
    true if due to Java orientation to the file system the file is executable. it follows File.canExecute()
    
    Overrides:
    
    canExecute in class java.io.File
  - getFlagsTested
```
public int getFlagsTested()
```
    Return the flags of the file after tested with file system itself. This operation may use more time if access to the file system is necessary.
    
    Returns:
    
    the flags, see mCanRead etc.
  - isSymbolicLink
```
public boolean isSymbolicLink()
```
  - getAbsolutePath
```
public java.lang.String getAbsolutePath()
```
    Overrides:
    
    getAbsolutePath in class java.io.File
  - listFiles
```
public FileRemote[] listFiles()
```
    This method overrides java.io.File.listFiles() but returns Objects from this class type.
    
    Overrides:
    
    listFiles in class java.io.File
    
    See Also:
    
    If the children files are gotten from the maybe remote file system, this method returns immediately with that result. But it may be out of date. The user can call {@link #refreshPropertiesAndChildren(CallbackEvent)} to get the new situation. If the children are not gotten up to now they are gotten yet. The method blocks until the information is gotten, see {@link FileRemoteAccessor#refreshFilePropertiesAndChildren(FileRemote, EventCmdPingPongType)} with null as event parameter.
  - listFiles
```
public java.io.File[] listFiles(java.io.FileFilter filter)
```
    Overrides:
    
    listFiles in class java.io.File
  - createNewFile
```
public boolean createNewFile()
                      throws java.io.IOException
```
    Overrides:
    
    createNewFile in class java.io.File
    
    Throws:
    
    java.io.IOException
  - delete
```
public boolean delete()
```
    Deletes this file, correct the parent's children list, remove this file.
    
    Overrides:
    
    delete in class java.io.File
    
    Returns:
    
    true if it is successfully deleted.
  - delete
```
public void delete(EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Deletes a file maybe in a remote device. This is a send-only routine without feedback, because the calling thread should not be waiting for success. The success is notified with invocation of the EventCmdPingPongType#callback.EventConsumer#processEvent(EventCmdPingPongType) method.
    
    Parameters:
    
    backEvent - The event for success. If null, delete in the same thread in the local file system.
  - mkdir
```
public boolean mkdir()
```
    Creates the directory named by this abstract pathname. This routine waits for execution on the file device. If it is a remote device, it may be spend some more time. See #mkdir(boolean, CallbackEvent). For local file system see File.mkdir().
    
    Overrides:
    
    mkdir in class java.io.File
    
    Returns:
    
    true if this operation was successfully. False if not.
  - mkdirs
```
public boolean mkdirs()
```
    Creates the directory named by this abstract pathname , including any necessary but nonexistent parent directories. Note that if this operation fails it may have succeeded in creating some of the necessary parent directories.
    This routine waits for execution on the file device. If it is a remote device, it may be spend some more time. See #mkdir(boolean, CallbackEvent). For local file system see File.mkdir().
    
    Overrides:
    
    mkdirs in class java.io.File
    
    Returns:
    
    true if this operation was successfully. False if not.
  - mkdir
```
public java.lang.String mkdir(boolean recursively,
                              EventWithDst<FileRemoteProgressEvData,FileRemoteCmdEventData> evBack)
```
    Creates the directory named by this abstract pathname
    
    Parameters:
    
    recursively - Creates necessary but nonexistent parent directories. Note that if this operation fails it may have succeeded in creating some of the necessary parent directories.
    
    evback - If given this routine does not wait. Instead the success will be sent with the given evback to the given destination routine given in its constructor CallbackEvent#CallbackEvent(EventConsumer, EventTimerThread, EventSource). If not given this routine waits till execution, see mkdir()
    
    Returns:
    
    false if unsuccessfully, true if evback !=null or successfully.
  - check
```
@Deprecated
public void check(java.lang.String sFiles,
                               java.lang.String sWildcardSelection,
                               FileRemoteProgressEvData evback)
```
    Deprecated.
    
    Checks a file maybe in a remote device maybe a directory. This is a send-only routine without immediate feedback, because the calling thread should not be waiting for success. The success is notified with invocation of the EventCmdPingPongType#callback.EventConsumer#processEvent(EventCmdPingPongType) method in the other execution thread or communication receiving thread.
    
    Parameters:
    
    sFiles - Maybe null or empty. If given, some file names separated with ':' or " : " should be used in this directory to check and select.
    
    sWildcardSelection - Maybe null or empty. If given, it is the select mask for files in directories.
    
    evback - The event instance for success. It can be contain a ready-to-use FileRemoteCmdEventData as its opponent. then that is used.
  - copyChecked
```
public void copyChecked(java.lang.String pathDst,
                        java.lang.String nameModification,
                        int mode,
                        FileRemoteWalkerCallback callbackUser,
                        FileRemoteProgressEvData timeOrderProgress)
```
    Copies all files which are checked before. this is the dir or file as root for copy to the given pathDst. The files to copy are marked in this directory or it is this file.
    
    The copying process is interactive. It is possible to ask whether files should be override etc, the progress is shown. For that the FileRemoteProgressEvData is used. This timeOrder should be created as overridden time order in the applications space with the application specific EventTimerThread_ifc instance. Especially it can be used in a graphical environment. See there to show a sequence diagram.
    
    The
    
    Parameters:
    
    pathDst - String given destination for the copy
    
    nameModification - Modification for each name. null then no modification. TODO
    
    mode - One of the bits modeCopyCreateYes etc.
    
    callbackUser - Maybe null, elsewhere on every directory and file which is finished to copy a callback is invoked.
    
    timeOrderProgress - may be null, to show the progress of copy.
  - copyTo
```
public void copyTo(FileRemote dst,
                   EventWithDst<FileRemoteProgressEvData,?> evBack,
                   int mode)
```
    Copies a file or directory tree to another file in the same device. The device is any file system maybe in a remote device. This is a send-only routine without immediate feedback, because the calling thread should not be waiting for success. The copy process is done in another thread.
    
    A feedback over the progress, for quests or the success of the copy process is given with evaluating of callback events. An event instance should be provided from the caller (param evback). This event instance is used and re-used for multiple callback events. If the event is occupied still from the last callback, a next status callback is suppressed. Therewith a flooding with non-processed events is prevented. If a quest is necessary or the success should be announced, that request should be waiting till the event is available with a significant timeout.
    
    The mode of operation, given in param mode, can be determine how several situations should be handled:
    - Overwrite write protected files: Bits modeCopyReadOnlyMask
      
      modeCopyReadOnlyAks: Send a callback event with the file name, wait for answer
    This routine sends a FileRemoteCmdEventData with FileRemoteCmdEventData.Cmd.copyChecked to the destination. Before that the destination for the event is set with calling of FileRemoteAccessor#prepareCmdEvent(CallbackEvent). That completes the given FileRemote.CallbackEvent with the necessary FileRemoteCmdEventData and its correct destination EventConsumer.
    
    Some status messages and the success is notified from the other thread or remote device with invocation of the given FileRemote.CallbackEvent. After any status message was received the FileRemoteCmdEventData gotten as EventCmdPingPongType#getOpponent() from the received FileRemote.CallbackEvent can be used to influence the copy process: The commands of the callback are:
    - CallbackCmd#done: The last callback to designate the finish of succession.
    - CallbackCmd#askDstNotAbletoOverwr: The destination file exists and it is readonly. It can't be set writeable though the modeCopyReadOnlyOverwrite designation was sent in the mode argument.
    - CallbackCmd#askDstOverwr: The destination file exits. Because modeCopyExistAsk is given it is the request for asking whether it should be overridden.
    - CallbackCmd#askDstReadonly: The destination file exists and it is read only. Because the modeCopyReadOnlyAks is given it is the request for asking whether it should be overridden though.
    - CallbackCmd#askErrorDstCreate: The destination file does not exists or it exists and it is writeable or set writeable. Nevertheless the creation or replacement of the file (open for write) fails. It is possible that the medium is read only or the user has no write access to the directory. Usual the copy of that file should be skipped sending FileRemoteCmdEventData.Cmd.abortCopyFile. On the other hand the user can clarify what's happen and then send FileRemoteCmdEventData.Cmd.overwr to repeat it.
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    - CallbackCmd#askDstNotAbletoOverwr: The destination file
    EventCmdPingPongType#callback.EventConsumer#processEvent(EventCmdPingPongType) method.
    Parameters:
    
    dst - This file will be created or filled newly. If it is existing but read only, nothing is copied and an error message is fed back.
    
    evback - The event for status messages and success.
  - XXXcopyTo
```
public void XXXcopyTo(FileRemote dst,
                      int mode)
```
  - moveTo
```
public void moveTo(java.lang.String sFiles,
                   FileRemote dst,
                   FileRemoteProgressEvData evback)
```
    Moves this file or some files in this directory to another file(s) maybe in a remote device. If the devices are the same, it sends a commission only to the device. The action is done in the other device respectively in another thread for local files in FileAccessorLocalJava7.executerCommission.
    
    Depending on the file system the moving may be a copy with deleting the source. But if this and dst are at the same partition, then it is a lightweight operation. If this and dst are at different partitions, the operation file system will be copy it and then delete this. It means, this operation can be need some time for large files.
    
    If this and dst are at different devices, this routine copies and deletes.
    
    It is a send-only routine without feedback in this routine, because the calling thread should not be waiting for success. The success is notified with invocation of the EventCmdPingPongType#callback.EventConsumer#processEvent(EventCmdPingPongType) method.
    
    Parameters:
    
    sFiles - maybe null or "". Elsewhere it contains a list of files in this directory which are to move. The files are separated with dots and can have white spaces before and after the dot for better readability. Write for example "myfile1.ext : myfile2.ext" If it is empty, this will be moved to dst.
    
    dst - The destination for move. If dst is a directory this file or directory tree will be copied into. If dst is an existing file nothing will be done and an error message will be fed back. If dst does not exist this will be stored as a new file or directory tree as dst. Note that this can be a file or a directory tree.
    
    backEvent - The event for success.
  - search
```
public void search(byte[] search,
                   FileRemoteWalkerCallback callbackUser,
                   FileRemoteProgressEvData timeOrderProgress)
```
    Search in all files. this is the dir or file as root for copy to the given pathDst. The files to copy are marked in this directory or it is this file.
    
    The copying process is interactive. It is possible to ask whether files should be override etc, the progress is shown. For that the FileRemoteProgressEvData is used. This timeOrder should be created as overridden time order in the applications space with the application specific EventTimerThread_ifc instance. Especially it can be used in a graphical environment. See there to show a sequence diagram.
    
    The
    
    Parameters:
    
    search - String given destination for the copy
    
    nameModification - Modification for each name. null then no modification. TODO
    
    mode - One of the bits modeCopyCreateYes etc.
    
    callbackUser - Maybe null, elsewhere on every directory and file which is finished to copy a callback is invoked.
    
    timeOrderProgress - may be null, to show the progress of copy.
  - chgProps
```
public void chgProps(boolean bWait,
                     java.lang.String newName,
                     int maskFlags,
                     int newFlags,
                     long newDate,
                     EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Change the file properties maybe in a remote device. A new name may be given as parameter. Some properties may be changed calling File.setWritable(boolean) etc. or they are given as parameter.
    
    It is a send-only routine without feedback in this routine, because the calling thread should not be waiting for success. The success is notified with invocation of the evback. The command itself uses the EventCmdtypeWithBackEvent#opponent which is type of FileRemoteCmdEventData to send the request.
    
    Parameters:
    
    newName - A new name for the file. This parameter may be null, then the old name remain.
    
    maskFlags - mask which flags should be changed
    
    newFlags - value of the flag bits.
    
    newDate - if not 0 a new time stamp of file
    
    evback - The event for success, containing the cmd event as opponent.
  - chgPropsRecursive
```
public void chgPropsRecursive(int maskFlags,
                              int newFlags,
                              long newDate,
                              EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Change the file properties maybe in a remote device. A new name may be given as parameter. Some properties may be changed calling File.setWritable(boolean) etc. or they are given as parameter.
    
    It is a send-only routine without feedback in this routine, because the calling thread should not be waiting for success. The success is notified with invocation of the EventCmdPingPongType#callback.EventConsumer#processEvent(EventCmdPingPongType) method.
    
    Parameters:
    
    newName - A new name for the file. This parameter may be null, then the old name remain.
    
    backEvent - The event for success.
  - countAllFileLength
```
public void countAllFileLength(EventWithDst<FileRemoteProgressEvData,?> evBack)
```
    Count the sum of length of all files in this directory tree.
    
    It is a send-only routine without feedback in this routine, because the calling thread should not be waiting for success. The success is notified with invocation of the EventCmdPingPongType#callback.EventConsumer#processEvent(EventCmdPingPongType) method.
    
    Parameters:
    
    newName - A new name for the file. This parameter may be null, then the old name remain.
    
    backEvent - The event for success.
  - abortAction
```
public void abortAction()
```
    It sends an abort event to the execution thread or to any remote device to abort any action with files. It aborts #copyTo(FileRemote, CallbackEvent, int), #check(FileRemote, CallbackEvent),
  - getStateDevice
```
public java.lang.CharSequence getStateDevice()
```
    Returns the state of the device statemachine, to detect whether it is active or ready.
    
    Returns:
    
    a String for debugging and show.
  - ident
```
public int ident()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.io.File
  - internalAccess
```
public FileRemote.InternalAccess internalAccess()
```
    This routine is only intent to access from a FileRemoteAccessor to any file. It is not intent to use by any application.

Class FileRemote

Nested Class Summary

Field Summary

Fields inherited from class java.io.File

Fields inherited from interface org.vishia.util.MarkMask_ifc

Constructor Summary

Method Summary

Methods inherited from class java.io.File

Methods inherited from class java.lang.Object

Field Detail

serialVersionUID

version

modeCopyReadOnlyMask

modeCopyReadOnlyNever

modeCopyReadOnlyOverwrite

modeCopyReadOnlyAks

modeCopyExistMask

modeCopyExistNewer

modeCopyExistOlder

modeCopyExistAll

modeCopyExistSkip

modeCopyExistAsk

modeCopyCreateMask

modeCopyCreateNever

modeCopyCreateYes

modeCopyCreateAsk

modeCmprLogNotEqualFiles

modeCmprLogMissing2File

modeCmprLogMissing1File

modeCmprLogComparedFiles

mExist

mCanRead

mCanWrite

mHidden

mDirectory

mFile

mExecute

mExecuteAny

mRelativePath

mAbsPath

mSymLinkedPath

mCanReadGrp

mCanWriteGrp

mExecuteGrp

mCanReadAny

mCanWriteAny

mRoot

mShouldRefresh

mThreadIsRunning

mRefreshChildPending

mTested

accessorSelector

ctIdent

_ident

clusterOfApplication

itsCluster

device

mark

timeRefresh

timeChildren

sDir

sFile

sCanonicalPath

date

dateCreation

dateLastAccess

length

flags

parent

children

oFile

path

evSrc

acc_

Constructor Detail

FileRemote

Method Detail

path

file

child