All Classes and Interfaces

Class
Description
AbstractExporterDelegate Abstract delegate used for archive export.
Base for on-demand input streams.
Base support for I/O Stream-based exporters
Represents a collection of resources which may be constructed programmatically.
An Asset representing an Archive; a specified StreamExporter type will be used to fulfill the Asset.openStream() contract.
Base implementation of Archive.
 
 
Exception thrown when an error occurs exporting an Archive.
Responsible for creating Archives, which may be presented to the caller in a designated Assignable view.
Supported archive formats known by the base implementation
Archive associable to an ArchiveFormat.
Value object binding the StreamExporter and the StreamImporter implementations of the same archive format.
Denotes an unexpected error was encountered while importing a Archive.
Represents a target context within an Archive under which an Node may be found.
A Factory for ArchivePath creation.
Singleton wrapper to obtain a root ArchivePath
Represents byte-based content.
AssetUtil Util class to help extract name/paths from Assets.
General interface for representing entities such as Archives, importers and exporters as different extension types.
A generic implementation of Assignable that delegates down to the Archive extensions inner archive.
A Path which may be optionally prefixed with some common namespace context at construction time.
Encapsulates the Burrows-Wheeler sorting algorithm needed by BZip2CompressorOutputStream.
Implementation of an Asset backed by a byte array
Package private class that helps get byte array from InputStream.
An input stream that decompresses from the BZip2 format to be read as any other stream.
 
An output stream that compresses into the BZip2 format into another stream.
 
Constants for both the compress and decompress BZip2 classes.
ClassAsset Implementation of a Asset backed by a loaded Class
Defines the contract for a component capable of storing Java Classes.
ClassloaderAsset Implementation of a Asset backed by a resource located in the Classloader.
Utilities to search a series of ClassLoaders for a Class by name.
Widens visibility such that any package within ShrinkWrap impl-base may access the utilities provided by ClassLoaderSearchUtil
Assignable view representing an entity backed by Configuration.
Assignable implementation view of an
invalid reference
ConfigurableArchive
.
Encapsulates all configuration for a given Domain.
Mutable construction object for new instances of Configuration.
ContainerBase Abstract class that helps implement the Archive, ManifestContainer, ResourceContainer, ClassContainer and LibraryContainer.
Obtains the Thread Context ClassLoader
A simple class the hold and calculate the CRC for sanity checking of the data.
Encapsulates a shared Configuration to be used by all Archives created by this Domain's ArchiveFactory.
Implementation of a Asset having empty content.
Traditional EAR (Java Enterprise Archive) structure.
EnterpriseArchiveImpl
Defines the contract for a component capable of storing Enterprise related resources.
EnterpriseContainerSupport Abstract class that helps implement the EnterpriseContainer.
IncludePaths Filter to exclude all ArchivePaths that match the given List of paths.
IncludeRegExpPath Filter to exclude all ArchivePaths that match a given Regular Expression.
Exporter used to export an Archive as an exploded directory structure.
ExplodedExporterDelegate Delegate used to export an archive into an exploded directory structure.
ExplodedExporterImpl Implementation of ExplodedExporter used to export an Archive as an exploded directory structure.
Importer used to import Exploded directory structures into a Archive
ExplodedImporterImpl Importer used to import Exploded directory structures into a Archive
ExtensionLoader Describes a way for the Archive to load extensions.
ExtensionLoadingException This Unchecked Exception Class is thrown from the ServiceExtensionLoader when something wrong has happened that we can not recover from.
ExtensionWrapper Wrapper used in the extensionMapping of ExtensionLoader Initialized in ServiceExtensionLoader.loadExtensionMapping(Class)
Implementation of an Asset backed by a File
Thrown to denote that an export request to a particular File has failed because the file specified already exists and should not be overwritten.
Used to filter inputs to be added to the target Archive.
Factory class for the creation of new Filter instances.
A type capable of formatting an Archive into human-readable style.
Available pre-configured Formatter instances used in constructing a human-readable form for a specified Archive.
Constants used in the default Formatter implementations
Simple Archive extension which closes the generic context as a convenience to users not requiring any spec archive type.
Implementation of a GenericArchive
Assignable view representing an entity with an ID.
Assignable implementation view of an Identifiable.
Exception thrown when trying to add a Node on and invalid path within the Archive (i.e.
Exception thrown when trying to add an Asset into an archive under an ArchivePath which is already taken by a directory.
IncludeAllClasses Filter to include all Classs
IncludeAllPaths Filter that include all ArchivePaths.
IncludePaths Filter to include all ArchivePaths that match the given List of paths.
IncludeRegExpPath Filter to include all ArchivePaths that match a given Regular Expression.
This exception is used to indicate that there is a problem with a TAR archive header.
Generic input/output utilities
IOUtilDelegator Class that helps expose package private ByteArrayIOUtil
Traditional JAR (Java Archive) structure.
Implementation of an archive with JAR-specific support.
Defines the contract for a component capable of storing Libraries.
Defines the contract for a component capable of storing Manifest related resources.
An Asset implementation backed by an internal memory representation; able to be directly added to an Archive, and supports all operations designated by the NIO.2 SeekableByteChannel API.
MemoryMapArchive A pure in memory Archive backed by a Map.
MemoryMapArchiveBase A base implementation for all MemoryMap archives.
MemoryMapArchiveImpl A default implementation for all MemoryMap archives.
MemoryAsset implementation complying to the NamedAsset API; thread-safe.
Pluggable separation between an Asset and a default name used to add Assets into an archive without having to explicitly supply the name (ArchivePath) each time.
Represents an entry inside an Archive.
The default implementation of Node
PathUtil A series of internal-only path utilities for adjusting relative forms, removing double-slashes, etc.
Random numbers for both the compress and decompress BZip2 classes.
Traditional RAR (Resource Adapter Archive) structure.
ResourceAdapterArchiveImpl
Defines the contract for a component capable of storing Resource adapter resources.
ResourceAdapterContainerBase Abstract class that helps implement the ResourceAdapter.
Defines the contract for a component capable of storing a series of ClassLoader, File, and URL-based Assets as resources within an archive.
SecurityActions A set of privileged actions that are not to leak out of this package
A set of privileged actions that are not to leak out of this package
SecurityActions A set of privileged actions that are not to leak out of this package
Single instance to get the TCCL
SeekableByteChannel implementation backed by an auto-resizing byte array; thread-safe.
Serializable view of an Archive.
ServiceExtensionLoader This class is the default strategy to load extensions when an instance of ExtensionLoader is not provided to the ConfigurationBuilder and the ConfigurationBuilder.build() method is invoked.
ServiceProviderAsset
Defines the contract for a component capable of storing service provider related resources.
Main entry point into the ShrinkWrap system.
Singleton wrapper to encapsulate a default domain
Extension that will create a ClassLoader based on a Array of Archives.
ShrinkWrap implementation of a DirectoryStream
ShrinkWrap implementation of BasicFileAttributes; not all operations are supported
ShrinkWrap implementation of a BasicFileAttributeView; immutable and Thread-safe
FileChannel implementation.
FileStore implementation for ShrinkWrap Archives; immutable and thread-safe.
ShrinkWrap implementation adapting a Archive to a FileSystem; Thread-safe, though access to the underlying Archive is *not*.
FileSystemProvider implementation for ShrinkWrap Archives.
Convenience API bridge to the NIO.2 FileSystems support for ShrinkWrap Archives.
NIO.2 Path implementation adapting to the ArchivePath construct in a ShrinkWrap Archive
Formatter implementation to provide a simple, one-line description of an Archive, including its name
Handler for errors that occur during StreamTask processing.
Generic exporter capable of representing an Assignable as an InputStream, or writing its contents to a provided OutputStream or File.
Generic importer capable of representing an Assignable as an entity capable of reading from an InputStream, or file type.
A I/O operation to be executed against a I/O stream in the context of a StreamTemplate
Implementation of an Asset backed by a String
The TarArchive class implements the concept of a tar archive.
The TarBuffer class implements the tar archive concept of a buffered input stream.
Exporter used to represent an Assignable in TAR format encoded w/ BZip2 compression
Implementation of an exporter for the TAR format, further encoded as BZip2.
Implementation of TarBz2Exporter used to export an Archive as a TAR format encoded in BZip2.
Assignable type capable of importing TAR archive content encoded in BZip2 compression.
Used to import existing TAR.BZ2 files/streams into the given Archive
TarBz on demand input stream.
The TarBzInputStream reads a UNIX TAR archive, further encoded in BZIP compresssion, as an InputStream.
Outputs tar.bz2 files.
This class represents an entry in a Tar archive.
Exporter used to represent an Assignable in TAR format
Implementation of an exporter for the TAR format
Implementation of TarExporter used to export an Archive as a TAR format.
Exporter used to represent an Assignable in TAR format encoded w/ GZIP compression
Implementation of an exporter for the TAR format, further encoded as GZIP.
Implementation of TarGzExporter used to export an Archive as a TAR format encoded in GZIP.
Assignable type capable of importing TAR archive content encoded in GZIP compression.
Used to import existing TAR.GZ files/streams into the given Archive
The TarGzInputStream reads a UNIX TAR archive, further encoded in GZIP compresssion, as an InputStream.
TarGz on demand input stream.
Outputs tar.gz files.
This class encapsulates the Tar Entry Header used in Tar Archives.
Assignable type capable of importing TAR archive content
Base of implementations used to import existing TAR files/streams into the given Archive
Used to import existing TAR files/streams into the given Archive
The TarInputStream reads a UNIX tar archive as an InputStream.
This interface is provided, with the method setEntryFactory(), to allow the programmer to have their own TarEntry subclass instantiated for the entries return from getNextEntry().
Tar on demand input stream.
Base for Tar related on-demand InputStreams.
Outputs TAR files; essentially a copy (ie.
The TarOutputStream writes a UNIX tar archive as an OutputStream.
This interface is provided to TarArchive to display progress information during operation.
This interface indicates if a file qualifies for ASCII translation.
Indicates that a default name cannot be generated for a given type because no extension mapping has been configured via ExtensionLoader.getExtensionFromExtensionMapping(Class).
UnknownExtensionTypeExceptionDelegator Delegator added to be able to reach UnknownExtensionTypeException from impl-base
Implementation of an Asset backed by a URL.
Implementation of scanner which can scan a URLClassLoader
Callback interface for found classes.
Validate Validation utility
Formatter implementation to provide an "ls -l"-esque output for an Archive, listing all internal contents in sorted order
Traditional WAR (Java Web Archive) structure.
WebArchiveImpl
Defines the contract for a component capable of storing web-related resources.
WebContainerBase Abstract class that helps implement the WebContainer.
Exporter used to represent an Assignable in ZIP format.
Implementation of a ZIP exporter.
Implementation of ZipExporter used to export an Archive as a ZIP format.
Holds a reference to the ZipFile and the ZipEntry this Asset represents for lazy loading.
Assignable type capable of importing ZIP content.
Used to import existing Zip files/streams into the given Archive
ZIP on demand input stream.
Serializable view of an Archive where contents are encoded in ZIP format during Serialization.
Implementation of a Serializable view of Archives, backed by ZIP en/decoding the contents during serialization/deserialization.