See: Description
| Interface | Description |
|---|---|
| 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.SymlinkInfo |
Information about files related to symbolic links.
|
| 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 filesystem event notification.
|
| RepositoryListener |
Listener to changes in the filesystem pool.
|
| StatusDecorator |
Provides decorations based on file state.
|
| Class | Description |
|---|---|
| AbstractFileSystem |
This convenience implementation does much of the hard work of
FileSystem and is generally more pleasant to create
subclasses of. |
| DefaultAttributes |
Implementation of
AbstractFileSystem.Attr using a special file
in each folder for holding attributes. |
| FileAttributeEvent |
Event used to listen on filesystem attribute changes.
|
| FileChangeAdapter |
Adapter for changes in
FileObjects. |
| FileEvent |
Event for listening on filesystem changes.
|
| FileLock |
Represents an acquired lock on a
FileObject. |
| FileObject |
This is the base for all implementations of file objects on a filesystem.
|
| 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.
|
| FileUtil |
Common utilities for handling files.
|
| JarFileSystem |
A virtual filesystem based on a JAR archive.
|
| JarFileSystem.Impl |
Implementation of all interfaces List, Change, Info and Attr
that delegates to JarFileSystem
|
| LocalFileSystem |
Local filesystem.
|
| LocalFileSystem.Impl |
The implementation class that implements List, Info
and Change interfaces and delegates all the methods
to appropriate methods of LocalFileSystem.
|
| MIMEResolver |
Use the
FileUtil.getMIMEType(org.openide.filesystems.FileObject, java.lang.String[])
to invoke the mime resolving infrastructure. |
| MultiFileSystem |
General base class for filesystems which proxy to others.
|
| Repository |
Holder for NetBeans default (system, configuration) filesystem, used for most
of NetBeans' runtime configuration.
|
| Repository.LayerProvider |
Contributes to content of
system file system
(which influences structure under FileUtil.getConfigRoot()). |
| Repository.LocalProvider |
Provides local repositories, depending on the current execution environment.
|
| RepositoryAdapter |
Dummy adapter for
RepositoryListener. |
| RepositoryEvent |
Event describing adding a filesystem to, or removing a filesystem from, the filesystem pool.
|
| RepositoryReorderedEvent |
Fired when a filesystem pool is reordered.
|
| URLMapper |
Mapper from FileObject -> URL.
|
| XMLFileSystem |
XML-based filesystem.
|
| XMLFileSystem.Impl |
Implementation of all interfaces List, Change, Info and Attr
that delegates to XMLFileSystem
|
| Exception | Description |
|---|---|
| FileAlreadyLockedException |
Exception raised when a file is already locked.
|
| FileStateInvalidException |
Signals that the file object is somehow corrupted.
|
| Annotation Type | Description |
|---|---|
| MIMEResolver.ExtensionRegistration |
Often a mime type can be deduced just by looking at a file extension.
|
| MIMEResolver.NamespaceRegistration |
Recognize mime type by looking into header of XML files.
|
| MIMEResolver.Registration |
Registration that allows effective, declarative registration of
complex
mime resolvers. |
NetBeans 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 NetBeans.
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 NetBeans may reflect that change; and providing support for including the filesystem in the runtime class path of an external compiler or executor.