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
Archive
s, 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.
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
Archive
s, 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 arrayPackage 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.
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
ClassLoader
s 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 Archive
s 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
ArchivePath
s that match the given List of paths.IncludeRegExpPath
Filter to exclude all
ArchivePath
s 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)
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.Constants used in the default
Formatter
implementationsSimple
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 an
Asset
into an archive under an ArchivePath
which is already
taken by a directory.IncludeAllClasses
Filter to include all
Class
sIncludeAllPaths
Filter that include all
ArchivePath
s.IncludePaths
Filter to include all
ArchivePath
s that match the given List of paths.IncludeRegExpPath
Filter to include all
ArchivePath
s 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 supportedShrinkWrap implementation of a
BasicFileAttributeView
; immutable and Thread-safeFileChannel
implementation.ShrinkWrap implementation adapting a
Archive
to a FileSystem
; Thread-safe, though access to the
underlying Archive
is *not*.FileSystemProvider
implementation for ShrinkWrap Archive
s.Convenience API bridge to the NIO.2
FileSystems
support for ShrinkWrap Archive
s.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 StringThe 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 compressionImplementation 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 formatImplementation 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 compressionImplementation 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 contentBase 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-baseImplementation of scanner which can scan a
URLClassLoader
Callback interface for found classes.
Validate
Validation utility
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 Archive
s, backed by ZIP en/decoding the contents during
serialization/deserialization.