Package net.openhft.chronicle.core.io

The resource management package provides classes and interfaces for managing the lifecycle of resources such as files, streams, and memory buffers.

See: Description

Interface Summary

Interface	Description
Closeable	A Closeable is a source or destination of data that can be closed.
ClosedState	Functional interface representing a closed state.
ManagedCloseable	The ManagedCloseable interface extends the Closeable interface and provides additional methods that are primarily intended for expert use cases involving resource lifecycle management.
Monitorable	Interface for objects that can be monitored and unmonitored.
MonitorReferenceCounted	This interface extends ReferenceCountedTracer and provides methods for monitoring the reference counted object.
QueryCloseable	An interface for querying the closeable state of an object.
ReferenceChangeListener	An interface to be notified when references to a ReferenceCounted are added, removed, or transferred.
ReferenceCounted	Represents a resource that is reference counted.
ReferenceCountedTracer	An interface for monitoring and tracing the reference counting of objects.
ReferenceOwner	Represents an entity that owns a reference, typically for resource management.
Resettable	An interface representing a DTO (Data Transfer Object) or component that can be reset to its initial state.
SingleThreadedChecked	An interface indicating that the implementing resource supports single-threaded access checking.
Syncable	An interface for objects that can be synced to underlying media if supported.
Validatable	The Validatable interface should be implemented by classes that require validation of their state before being written through a method writer.

Class Summary

Class	Description
AbstractCloseable	An abstract class that represents a closeable resource with additional utilities for managing the resource lifecycle.
AbstractCloseableReferenceCounted	Represents a closeable resource with reference counting capabilities.
AbstractReferenceCounted	Abstract base class for managing reference-counted resources.
BackgroundResourceReleaser	Utility class for managing reference counted resources and related operations.
CleaningRandomAccessFile	A RandomAccessFile must be explicitly close or cause a resources leak.
IOTools	IOTools is a utility class containing a variety of methods and constants designed for handling input/output (IO) operations, especially regarding file and directory manipulation.
SimpleCloseable	An abstract class providing a basic implementation of the Closeable, ReferenceOwner, and ManagedCloseable interfaces.
TracingReferenceCounted
UnsafeCloseable	An abstract base class for resources that use the Unsafe class for low-level memory operations.
ValidatableUtil	Utility class for validating objects and managing validation settings.
VanillaReferenceCounted	This class provides a basic implementation of the MonitorReferenceCounted interface.
VanillaReferenceOwner	A simple implementation of the ReferenceOwner and QueryCloseable interfaces.
Wget	Utility class for performing an HTTP GET request.

Exception Summary

Exception	Description
ClosedIllegalStateException	ClosedIllegalStateException is thrown to indicate that a method has been invoked on a resource that is in an inappropriate state because it has been closed.
ClosedIORuntimeException	ClosedIORuntimeException is thrown to indicate that an I/O operation has been attempted on a closed I/O resource, such as a file or network connection.
InvalidMarshallableException	InvalidMarshallableException is thrown to indicate that an object being serialized (marshalled) or deserialized (unmarshalled) is in an invalid state.
IORuntimeException	IORuntimeException is a runtime exception that is thrown when an operation involving an underlying IO resource fails or is unable to complete.
ThreadingIllegalStateException	A custom exception indicating an illegal access or operation due to threading constraints.

Package net.openhft.chronicle.core.io Description

The resource management package provides classes and interfaces for managing the lifecycle of resources such as files, streams, and memory buffers. It includes abstractions for reference counting, closing resources, and utilities for background resource release.

Features

• Abstract base classes for resources requiring close operations with thread-safety guarantees.
• Reference counting capabilities for efficient resource management.
• Utilities for managing reference counted resources in the background.
• Interfaces for querying the closeable state of an object.
• Interfaces for validating objects before serialization or deserialization.
• Custom exceptions for indicating illegal state due to resource closure.
• Support for tracking and monitoring reference counts and resource owners.
• Support for single-threaded access checking.

Key Classes and Interfaces

• AbstractCloseable - Base class for closeable resources with additional utilities for managing the resource lifecycle.
• AbstractCloseableReferenceCounted - Represents a closeable resource with reference counting capabilities.
• BackgroundResourceReleaser - Utility class for managing reference counted resources and related operations in the background.
• Closeable - Interface for a source or destination of data that can be closed.
• ReferenceOwner - Represents an entity that owns a reference.
• ManagedCloseable - Extends the Closeable interface providing additional methods for expert use cases involving resource lifecycle management.
• ReferenceCounted - Represents a resource that is reference counted.
• Validatable - Interface for objects that require validation of their state before being written through a method writer.

Custom Exceptions

• ClosedIllegalStateException - Indicating that a method has been invoked on a closed resource.
• ClosedIORuntimeException - Indicating that an I/O operation has been attempted on a closed I/O resource.
• InvalidMarshallableException - Indicating that an object being serialized or deserialized is in an invalid state.
• IORuntimeException - A runtime exception thrown when an operation involving an underlying IO resource fails.

Use Cases

This package can be used in scenarios where there is a need to manage the lifecycle of resources, especially those requiring closing operations. Examples include:

• File handling systems.
• Network connections management.
• Memory buffer management.
• Database connections pooling.

Examples

 try (CloseableResource resource = new CloseableResource()) {
     // use the resource
 } catch (IORuntimeException e) {
     // handle exception
 }
 

See Also:

Closeable, ManagedCloseable