All Classes and Interfaces
Class
Description
A parser for the Accept-Encoding http header.
Enum representing activation types for various components in the CraftsNet framework.
Abstract class representing an addon that extends the functionality of the application without modifying its core.
Class responsible for loading addons dynamically into the CraftsNet framework.
Represents the configuration details of an
Addon, including its metadata, classpath, and dependencies.Builder class for configuring the CraftsNet with a set of addons.
The AddonLoader class is responsible for loading and managing addons in the application.
The AddonManager class is responsible for managing addons in the application.
Represents metadata information for an addon, such as its name, main class, authors, website, version, and dependencies.
The
AllAddonsDisabledEvent class represents an event triggered when all addons are disabled within CraftsNet.The AddonsLoadedEvent class represents an event triggered when all addons are loaded within CraftsNet.
Specifies a
WebSocketSafeTypeDecoder to be applied to the second parameter
of a WebSocket handler method.Annotation to set specific
middlewares to be used before the endpoint
is performed.The
ApplyMiddleware.List annotation is used to repeat the ApplyMiddleware
annotation.The
ArtifactLoader class provides functionality for resolving and loading libraries (artifacts)
for addons in a modular system.The
AutoRegister is an annotation used to mark classes for automatic registration
during the startup process.The
AutoRegisterHandler class is an abstract base class designed to handle objects
during the auto registration process.The
AutoRegisterInfo holds information about a class to be processed in an auto registration
process.A loader class responsible for loading classes from a JAR file that are annotated with a specific annotation
(default is
AutoRegister) and collecting relevant information about these classes.The
AutoRegisterRegistry is responsible for managing and invoking AutoRegisterHandler instances
based on the provided AutoRegisterInfo.Acts as the base for all exchanges that exists.
A built-in
LogStreamMutator that blurs or censors IP addresses in log lines.The abstract class
Body is the base class for all types of HTTP request bodies
supported by CraftsNet.A handler for automatically registering
BodyParser implementations.This abstract class represents a parser for HTTP request or response bodies.
This class represents a registry for body parsers used in HTTP request processing.
A specific web requirement that checks if the body of an HTTP request matches certain criteria.
A transformer class for converting a string representation of a boolean value to a Boolean object.
The
ByteArrayBody class represents an http request body which
contains byte[] data.This class is a body parser specifically designed to parse
ByteArrayBody request bodies.A custom
ByteBuffer implementation that provides both read and write operations
for byte arrays.A transformer class for converting a string representation of a byte value to a Byte object.
The ClientConnectEvent class represents an event related to a client connection to a socket.
The ClientDisconnectEvent class represents an event related to a client disconnection from a websocket connection.
Enumeration representing WebSocket closure codes along with their integer values and internal status.
A generic base interface for codecs, combining encoding and decoding operations.
A sealed base class representing a binding between a target type and a corresponding codec.
The
Command class represents a command that can be executed.The
CommandExecutor interface represents an object capable of executing commands.The
CommandRegistry class manages and provides access to registered commands.The
ConsoleListener class is responsible for handling console messages and executing commands.The ConsoleMessageEvent class represents an event related to a console message.
Enum representing different types of constructors used in automatic instance creation
or dependency injection mechanisms.
This interface defines constants for commonly used Content-Type headers in HTTP requests and responses.
A specific web requirement that checks if the content-type of an HTTP request matches certain criteria.
Represents a http cookie with various attributes such as name, value, path, domain, expiry date,
same-site policy, security, and HttpOnly flag.
A specific web requirement that checks if the cookie list of an HTTP request matches certain criteria.
Represents a Cross-Origin Resource Sharing (CORS) policy, which defines how requests
from other origins (domains) can interact with the server's resources.
CraftsNet class represents the core component of the CraftsNet framework,
providing functionalities for managing various aspects of the system.
Builder class for configuring the CraftsNet.
A specialized class loader for loading classes and resources in the context of a
CraftsNet instance.A generic interface for decoding data from one type into another.
A pairing between a specific target type and its associated
Decoder.A default implementation of a ping responder for handling incoming ping messages.
Represents a default route handler implementation.
A concrete implementation of
StreamEncoder that performs compression and decompression
using the Deflate algorithm.Class responsible for loading dependencies dynamically into the CraftsNet framework.
Declares a dependency for an
Addon.A container annotation for grouping multiple
Depends annotations.Specifies the domain associated with an HTTP request handler or service.
A transformer class for converting a string representation of a double value to a Double object.
A generic interface for encoding data from one type into another.
A pairing between a specific target type and its associated
Encoder.An abstract class extending
CancellableEvent, providing the ability to set and retrieve
a custom cancellation reason.Represents the exchange of data between the client (request) and the server (response).
This annotation is used to mark a constructor as a fallback constructor.
A utility class that helps manage the creation of temporary files in the file system.
A file based implementation of
SessionDriver that persists session data to disk.A transformer class for converting a string representation of a float value to a Float object.
The
FormBody class is an abstract base class for representing HTTP request bodies that
contain form data.Represents a WebSocket frame that contains control information and payload data.
A concrete implementation of the
ServiceLoader interface for managing instances of Handler.Represents the base for all request events.
Represents the base for all websocket events.
Represents the base for all websocket message events.
A concrete implementation of
StreamEncoder that performs compression and decompression
using the GZIP algorithm.Represents a contract for classes that handle any type of connections in a server application.
A handler for automatically registering
Handler implementations.A specific web requirement that checks if the headers of an HTTP request matches certain criteria.
An instance of
Addon which is only capable of holding dummy
data of an addon that did not specify a valid main class.A specific web requirement that checks if the domain of an HTTP request matches certain criteria.
The RequestMethod enum represents the different HTTP request methods, such as POST, GET, PUT, DELETE, PATCH, and HEAD.
A specific
middleware for manipulating http
requests.A concrete implementation of
StreamEncoder that performs no encoding
and returns the input and output streams as they are.This annotation is used to mark a constructor that should be ignored.
A concrete implementation of the
ServiceLoader interface for managing instances of IIOServiceProvider.The IncomingSocketMessageEvent class represents an event related to an incoming message on a websocket connection.
The
Instantiate enum defines the different ways an instance of a class
can be managed during the auto registration process.A transformer class for converting a string representation of an integer value to an Integer object.
The
JsonBody class represents an http request body which
contains Json data.This class is a body parser specifically designed to parse json request bodies.
A concrete implementation of the
ServiceLoader interface for managing instances of ListenerAdapter.A handler for automatically registering
ListenerAdapter implementations.A logger interface for logging messages at different severity levels.
The LoggerImpl class provides a simple logging mechanism for displaying log messages in the console with different log levels.
An enumeration of log levels used for categorizing log messages.
A utility class for logging to files.
Functional interface for mutating log output lines before they are written to the output stream.
A handler for automatically registering
LogStreamMutator implementations.A transformer class for converting a string representation of a long value to a Long object.
A specific websocket requirement that checks if the domain of a websocket connection matches certain criteria.
Provides basic metadata for
Addon.A specific web requirement that checks if the request method of an HTTP request matches certain criteria.
Represents a basic
middleware that can be used in context with
exchanges to manipulate the behaviour of the application
without interacting with the built-in listener system.A handler for automatically registering
Middleware implementations.The
MiddlewareCallbackInfo is used to pass information between the different
middlewares.A concrete implementation of the
ServiceLoader interface for managing instances of Middleware.A registry for resolving and storing
middlewares.The
MultipartFormBody class represents an HTTP request body that contains data in the
multipart/form-data format.The
MultipartData class represents the multipart data for a single field in the
multipart/form-data.The
MultipartItem class represents an individual part of the multipart data, which
can be a file or a form field.This class is a body parser specifically designed to parse multipart form data request bodies.
An implementation of the
Logger interface that performs no operations.This exception is thrown when a parameter cannot be transformed to a specified target type.
Enumeration representing WebSocket opcodes along with their integer values.
The OutgoingSocketMessageEvent class represents an event related to an outgoing message on a websocket connection.
This utility class provides helper methods for generating passphrases.
WebSocket extension that implements per-message deflate compression as described in
RFC 7692.
An implementation of the
Logger interface that prints the result
in the System.out or the System.err stream, without any
further formating.Command executor for the plugin command.
This event is triggered after an HTTP request has been processed.
This annotation is used to mark a constructor as the preferred constructor.
This event is triggered before a http request is processed as route or share.
Annotation to define the processing priority of a method.
Enumeration representing different priority levels.
Represents a specific version of a protocol, including its scheme, major version, and minor version.
A specific web requirement that checks if the url parameter list of an HTTP request matches certain criteria.
An event indicating that a Ping message has been received.
An event indicating that a Pong message has been received.
Some reflection utilities.
Represents a registered service, encapsulating the service provider interface (SPI)
and the provider information in a concise record.
Command executor for the reload command.
The Request class represents an incoming HTTP request received by the web server.
The RequestHandler interface serves as a marker interface for classes that are intended to handle incoming HTTP requests.
A concrete implementation of the
ServiceLoader interface for managing instances of RequestHandler.Specifies the HTTP request methods that are supported by the service method.
Marker interface representing a class that contains information which can be used to
feed the requirement system.
Annotation used to indicate that a request handler method requires specific types of request bodies.
This annotation can be applied to methods or types to indicate that
certain content types are required for processing the request.
Annotation to specify required cookies for methods or types.
Annotation to specify required HTTP headers for methods or types.
Represents an abstract requirement that can be used in the requirement system.
Represents detailed information about a specific requirement annotation.
Annotation to define metadata for custom requirement annotations.
The
RequirementRegistry class manages the registration and unregistration of Requirement.Annotation to mark methods within a requirement annotation for value storage.
Represents the different types of requirements that can be defined for annotations.
Specifies the message type that should be received.
Annotation to specify required url parameters for methods or types.
The Response class represents an HTTP response sent by the web server to the client.
Specifies the path associated with a service method or defines the parent path.
The RouteRegistry class manages the registration and unregistration of
RequestHandler (routes) and SocketHandler (websockets).Represents the mapping of a registered endpoint handler.
A universal interface for mappings.
The ShareMapping class represents the mapping of a registered shared endpoint.
The
RouteRequestEvent class represents an event related to a route request.Enumeration representing the SameSite attribute of a cookie.
Enum representing different schemes (protocols) supported by the system.
Utility class for secure encoding and decoding of character arrays to byte arrays and vice versa.
Abstract class representing a server in the CraftsNet framework.
A simple service loader interface for managing instances of a specified type.
A handler for automatically registering
ServiceLoader implementations.The ServiceManager class represents a manager responsible for handling various service loaders in a system.
Manages session data, allowing the storage and retrieval of serialized objects
within a json file.
A specialized cache for managing
Session objects, allowing efficient storage
and retrieval of session instances using unique string keys.Interface representing a driver responsible for session persistence operations.
Manages session metadata and handles the persistence and lifecycle of sessions.
Handles the persistence of session data by providing functionality for loading, saving,
and destroying session files.
Indicating the type of job the
SessionStorage is performing.Indicates that the annotated
Addon requires a dependency
or repository.Container annotation for grouping multiple
Shadow annotations.Enum representing the types of resources in an addon context.
Represents an event that is triggered when a share file has been loaded.
Represents an event that is triggered when a share request is made.
A transformer class for converting a string representation of a short value to a Short object.
The
ShutdownCommand class implements the CommandExecutor interface
and defines the behavior of the "shutdown" command.Custom annotation used to mark classes as WebSocket handlers.
The SocketExchange record represents an exchange object that provides a way to interact
with the WebSocket server and client within the context of a WebSocket connection.
Represents a contract for classes that handle WebSocket connections in a server application.
A concrete implementation of the
ServiceLoader interface for managing instances of SocketHandler.A concrete implementation of the
ServiceLoader interface for managing instances of Driver.The SSL class encapsulates a collection of utility methods aimed at facilitating SSL/TLS functionality
within an application.
The
StandardFormBody class represents an HTTP request body that contains form data
encoded in the standard application/x-www-form-urlencoded format.This class is a body parser specifically designed to parse standard form request bodies.
Enum representing the different stages of the loading process of addons.
Abstract class representing a stream encoder, which can be used to encode and decode input and output streams.
A handler for automatically registering
StreamEncoder implementations.A registry for managing and retrieving
StreamEncoder instances.The
StringBody class represents an http request body which
contains String data.This class is a body parser specifically designed to parse
StringBody request bodies.Interface representing a transformation operation.
Annotation to mark methods or types that provide transformation functionality.
Annotation to mark a collection of transformer annotations.
The TransformerErrorCallback interface defines a contract for handling transformer errors within the CraftsNet API.
This class represents an exception that occurs during data transformation operations.
The TransformerPerformer class is responsible for performing transformations on method arguments based on provided annotations.
A base registry class for managing codecs that handle conversion between types.
The
TypedBody class represents an http request body containing
specific typed data.This class is a body parser specifically designed to parse
TypedBody request bodies.A concrete implementation of
TypeCodecRegistry for managing Decoder instances.A specialized implementation of
TypeCodecRegistry for managing Encoder instances.Utility class for handling Java primitive types and their wrapper classes.
Exception thrown when an unknown or unsupported scheme is encountered.
This utility class provides helper methods for general operations.
Command executor for the version command.
Utility class for handling version comparison logic in the CNet system.
Handles HTTP requests and routes them to the appropriate handlers based on the registered routes.
Abstract class representing a web specific requirement.
A handler for automatically registering
WebRequirement implementations.The WebServer class represents a simple HTTP or HTTPS server that listens for incoming requests and handles
them based on registered API endpoints using the provided RouteRegistry.
The WebSocketClient class represents a WebSocket client that connects to the WebSocketServer.
Abstract base class for WebSocket extensions.
A handler for automatically registering
WebSocketExtension implementations.Registry for managing WebSocket extensions.
A specific
middleware for manipulating websocket
clients connections.Abstract class representing a websocket specific requirement.
A handler for automatically registering
WebSocketRequirement implementations.A sealed
Encoder for safely encoding types for WebSocket communication.An encoder that transforms a specific input type into a
byte[] representation
suitable for binary WebSocket frames.An encoder that transforms a specific input type into a
ByteBuffer representation.An encoder that transforms a specific input type into a
Json representation,
typically for use with text-based WebSocket frames.An encoder that transforms a specific input type into a
String representation,
typically for use with text-based WebSocket frames.The WebSocketServer class represents a simple WebSocket server implementation.
A handler for automatically registering
WebSocketSafeTypeDecoder implementations.A handler for automatically registering
WebSocketSafeTypeEncoder implementations.A specific websocket requirement that checks if the domain of a websocket connection matches certain criteria.