Package org.openide.filesystems

The IDE internally uses the concept of a virtual filesystem.

See:
Description

Interface Summary

AbstractFileSystem.Attr	Handle attributes of files.
AbstractFileSystem.Change	Controls modification of files.
AbstractFileSystem.Info	Information about files.
AbstractFileSystem.List	Provides access to the hierarchy of resources.
AbstractFileSystem.Transfer	Controls on moving of files.
FileChangeListener	Listener for changes in FileObjects.
FileStatusListener	Listener to changes in annotation of file objects.
FileSystem.AtomicAction	An action that it is to be called atomically with respect to file system event notification.
FileSystem.Status	Allows a filesystem to annotate a group of files (typically comprising a data object) with additional markers.
RepositoryListener	Listener to changes in the file system pool.

Class Summary

AbstractFileSystem	Implementation of FileSystem that simplifies the most common tasks.
DefaultAttributes	Implementation of AbstractFileSystem.Attr using a special file in each folder for holding attributes.
FileAttributeEvent	Event used to listen on file system attribute changes.
FileChangeAdapter	Adapter for changes in FileObjects.
FileEvent	Event for listening on file system changes.
FileLock	Represents an acquired lock on a FileObject.
FileObject	This is the base for all implementations of file objects on a file system.
FileRenameEvent	Event indicating a file rename.
FileStatusEvent	Event describing a change in annotation of files.
FileSystem	Interface that provides basic information about a virtual filesystem in the IDE.
FileSystem.Environment	Interface that allows filesystems to set up the Java environment for external execution and compilation.
FileSystemCapability	This class defines the capabilities of a file system to take part in different operations.
FileSystemCapability.Bean	Default implementation of capabilities, that behaves like JavaBean and allows to set whether the well known capabilities (like compile, execute) should be enabled or not.
FileUtil	Common utilities for handling files.
JarFileSystem	A virtual file system based on a JAR archive.
JarFileSystem.Impl	Implementation of all interfaces List, Change, Info and Attr that delegates to JarFileSystem
LocalFileSystem	Local file system.
LocalFileSystem.Impl	The implementation class that implements List, Info and Change interfaces and delegates all the methods to appropriate methods of LocalFileSystem.
MIMEResolver	This class is intended as superclass for individual resolvers.
MultiFileSystem	The base for all filesystems that are build above a top of other ones.
Repository	This singleton object contains all FileSystems in the IDE.
RepositoryAdapter	Dummy adapter for RepositoryListener.
RepositoryEvent	Event describing adding a file system to, or removing a file system from, the file system pool.
RepositoryReorderedEvent	Fired when a file system pool is reordered.
XMLFileSystem	XML-based file system.
XMLFileSystem.Impl	Implementation of all interfaces List, Change, Info and Attr that delegates to JarFileSystem

Exception Summary

EnvironmentNotSupportedException	Exception thrown to signal that external execution and compilation is not supported on a given filesystem.
FileAlreadyLockedException	Exception raised when a file is already locked.
FileStateInvalidException	Signals that the file object is somehow corrupted.

Package org.openide.filesystems Description

The IDE internally uses the concept of a virtual filesystem. This interface is used by all upper layers of the IDE to read & write files, mount & display directories, move and delete files, and allow external compilation and execution to find libraries correctly.

The IDE itself implements two filesystems: a local filesystem, which encapsulates access to the operating system's normal files; and a JAR filesystem, which allows users to mount Java Archive Files as if they were read-only directories.

Using the FileSystems API, third parties may add support for access to file-like objects stored in some different manner - for example, in a database or proprietary object storage system. More commonly, module authors should use this API whenever they need access to files; then their module should work automatically with any filesystem supported by the IDE.

Other capabilities provided by the FileSystems API include locking files during write operations; listening for changes in a file's status, so that another part of the IDE may reflect that change; and providing support for including the filesystem in the runtime class path of an external compiler or executor.