tessl/maven-org-eclipse-jetty--jetty-http

Core HTTP protocol support library for Eclipse Jetty providing header handling, parsing, generation, compliance validation, and content processing capabilities

—

Pending

Overview

Eval results

Files

HTTP Headers and Fields

Name: tessl/maven-org-eclipse-jetty--jetty-http
Author: tessl

Comprehensive HTTP header handling with optimized field collections, type-safe header enums, efficient header value processing, and immutable/mutable field collections.

Capabilities

HttpHeader Enumeration

Complete enumeration of standard HTTP headers with efficient lookup and caching.

/**
 * Enumeration of standard HTTP headers with efficient processing
 */
enum HttpHeader {
    // General headers
    CONNECTION, CACHE_CONTROL, DATE, PRAGMA, TRANSFER_ENCODING, UPGRADE, VIA, WARNING,
    
    // Entity headers
    ALLOW, CONTENT_DISPOSITION, CONTENT_ENCODING, CONTENT_LANGUAGE, 
    CONTENT_LENGTH, CONTENT_TYPE, EXPIRES, LAST_MODIFIED,
    
    // Request headers
    ACCEPT, ACCEPT_CHARSET, ACCEPT_ENCODING, ACCEPT_LANGUAGE, AUTHORIZATION, 
    HOST, IF_MATCH, IF_MODIFIED_SINCE, IF_NONE_MATCH, IF_RANGE, 
    IF_UNMODIFIED_SINCE, REFERER, USER_AGENT,
    
    // Response headers
    ACCEPT_RANGES, AGE, ETAG, LOCATION, PROXY_AUTHENTICATE, 
    RETRY_AFTER, SERVER, VARY, WWW_AUTHENTICATE,
    
    // CORS headers
    ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_ALLOW_METHODS, 
    ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_CREDENTIALS,
    ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_MAX_AGE,
    
    // WebSocket headers
    SEC_WEBSOCKET_KEY, SEC_WEBSOCKET_VERSION, SEC_WEBSOCKET_ACCEPT,
    SEC_WEBSOCKET_PROTOCOL, SEC_WEBSOCKET_EXTENSIONS,
    
    // HTTP/2 pseudo headers
    C_METHOD, C_SCHEME, C_AUTHORITY, C_PATH, C_STATUS;
    
    /** Get lowercase header name */
    String lowerCaseName();
    
    /** Get header name as ByteBuffer */
    ByteBuffer toBuffer();
    
    /** Get header name as byte array */
    byte[] getBytes();
    
    /** Case-insensitive header name comparison */
    boolean is(String s);
    
    /** Check if this is an HTTP/2 pseudo header */
    boolean isPseudo();
    
    /** Header name cache for efficient lookup */
    static final Index<HttpHeader> CACHE;
    
    /** Content-related headers set */
    static final EnumSet<HttpHeader> CONTENT_HEADERS;
}

HttpHeaderValue Enumeration

Common HTTP header values with efficient processing and CSV parsing support.

/**
 * Enumeration of common HTTP header values
 */
enum HttpHeaderValue {
    CLOSE, CHUNKED, GZIP, DEFLATE, IDENTITY, KEEP_ALIVE, CONTINUE, 
    BYTES, NO_CACHE, NO_STORE, MAX_AGE, MUST_REVALIDATE, UPGRADE,
    WEBSOCKET, TEXT_PLAIN, APPLICATION_JSON, APPLICATION_XML;
    
    /** Get value as ByteBuffer */
    ByteBuffer toBuffer();
    
    /** Case-insensitive value comparison */
    boolean is(String s);
    
    /** Get value as string */
    String asString();
    
    /** Check if header has known values */
    static boolean hasKnownValues(HttpHeader header);
    
    /** Parse CSV header values with callback */
    static boolean parseCsvIndex(String value, Function<HttpHeaderValue, Boolean> found);
}

HttpField Class

Immutable HTTP header field with name and value, supporting typed access and field manipulation.

/**
 * Immutable HTTP header field with name and value
 */
class HttpField {
    /** Create field with header enum and value */
    HttpField(HttpHeader header, String value);
    
    /** Create field with header enum, name override, and value */
    HttpField(HttpHeader header, String name, String value);
    
    /** Create field with header enum and header value enum */
    HttpField(HttpHeader header, HttpHeaderValue value);
    
    /** Create field with string name and value */
    HttpField(String name, String value);
    
    /** Get header enum if known, null otherwise */
    HttpHeader getHeader();
    
    /** Get field name */
    String getName();
    
    /** Get lowercase field name */
    String getLowerCaseName();
    
    /** Get field value */
    String getValue();
    
    /** Get multi-value field as array */
    String[] getValues();
    
    /** Get multi-value field as list */
    List<String> getValueList();
    
    /** Get value as integer */
    int getIntValue();
    
    /** Get value as long */
    long getLongValue();
    
    /** Check if value contains string (case insensitive) */
    boolean contains(String search);
    
    /** Check if last value contains string */
    boolean containsLast(String search);
    
    /** Check field name (case insensitive) */
    boolean is(String name);
    
    /** Compare field names */
    boolean isSameName(HttpField field);
    
    /** Create new field with different value */
    HttpField withValue(String value);
    
    /** Create new field with multiple values */
    HttpField withValues(String... values);
    
    /** Create new field removing a value */
    HttpField withoutValue(String value);
    
    /** Extract parameters from header value */
    static String getValueParameters(String valueParams, Map<String, String> parameters);
    
    /** Remove parameters from header value */
    static String stripParameters(String value);
    
    /** Check if value contains search string */
    static boolean contains(String value, String search);
    
    /** Check if last value contains search string */
    static boolean containsLast(String value, String search);
    
    /** Parameter parsing tokenizer */
    static final QuotedStringTokenizer PARAMETER_TOKENIZER;
    
    /** Name-value parsing tokenizer */
    static final QuotedStringTokenizer NAME_VALUE_TOKENIZER;
}

/**
 * Optimized integer value field
 */
class IntValueHttpField extends HttpField {
    IntValueHttpField(HttpHeader header, String name, String value, int intValue);
    IntValueHttpField(HttpHeader header, String value, int intValue);
    IntValueHttpField(HttpHeader header, int intValue);
}

/**
 * Optimized long value field  
 */
class LongValueHttpField extends HttpField {
    LongValueHttpField(HttpHeader header, String name, String value, long longValue);
    LongValueHttpField(HttpHeader header, String value, long longValue);
    LongValueHttpField(HttpHeader header, long longValue);
}

HttpFields Interface

Collection interface for HTTP header fields with lookup, iteration, and streaming support.

/**
 * Collection of HTTP header fields
 */
interface HttpFields extends Iterable<HttpField> {
    /** Number of fields */
    int size();
    
    /** Get field by index */
    HttpField getField(int index);
    
    /** Get first field by name (case insensitive) */
    HttpField getField(String name);
    
    /** Get first field by header enum */
    HttpField getField(HttpHeader header);
    
    /** Get all fields with name */
    List<HttpField> getFields(String name);
    
    /** Get all fields with header enum */
    List<HttpField> getFields(HttpHeader header);
    
    /** Get first value by name */
    String get(String name);
    
    /** Get first value by header enum */
    String get(HttpHeader header);
    
    /** Get all values as list */
    List<String> getValuesList(String name);
    
    /** Check if field with name exists */
    boolean contains(String name);
    
    /** Check if field with header exists */
    boolean contains(HttpHeader header);
    
    /** Check if field with name and value exists */
    boolean contains(String name, String value);
    
    /** Get integer field value */
    int getIntField(String name);
    
    /** Get long field value */
    long getLongField(String name);
    
    /** Stream of all fields */
    Stream<HttpField> stream();
    
    /** Iterator over all fields */
    Iterator<HttpField> iterator();
}

MutableHttpFields Class

Mutable collection of HTTP fields with add, put, and remove operations.

/**
 * Mutable collection of HTTP fields
 */
class MutableHttpFields implements HttpFields {
    /** Create empty fields collection */
    MutableHttpFields();
    
    /** Create with initial capacity */
    MutableHttpFields(int capacity);
    
    /** Copy constructor */
    MutableHttpFields(HttpFields fields);
    
    /** Add or replace field (returns previous field if any) */
    HttpField put(String name, String value);
    
    /** Add or replace field by header enum */
    HttpField put(HttpHeader header, String value);
    
    /** Add or replace existing field */
    HttpField put(HttpField field);
    
    /** Add field (allows duplicates) */
    HttpField add(String name, String value);
    
    /** Add field by header enum */
    HttpField add(HttpHeader header, String value);  
    
    /** Add existing field */
    HttpField add(HttpField field);
    
    /** Remove all fields with name */
    boolean remove(String name);
    
    /** Remove all fields with header enum */
    boolean remove(HttpHeader header);
    
    /** Remove specific field */
    HttpField remove(HttpField field);
    
    /** Remove all fields */
    void clear();
    
    /** Ensure capacity for fields */
    int ensureCapacity(int capacity);
}

ImmutableHttpFields Class

Immutable collection of HTTP fields with builder pattern.

/**
 * Immutable collection of HTTP fields
 */
class ImmutableHttpFields implements HttpFields {
    /** Create builder for immutable fields */
    static Builder builder();
    
    /** Create from field array */
    static ImmutableHttpFields of(HttpField... fields);
    
    /** Build from field array */
    static ImmutableHttpFields build(HttpField... fields);
    
    /**
     * Builder for immutable HTTP fields
     */
    static class Builder {
        Builder add(String name, String value);
        Builder add(HttpHeader header, String value);
        Builder add(HttpField field);
        Builder put(String name, String value);
        Builder put(HttpHeader header, String value);
        Builder put(HttpField field);
        ImmutableHttpFields build();
    }
}

EmptyHttpFields Class

Singleton empty fields collection for efficiency.

/**
 * Immutable empty HTTP fields collection
 */
class EmptyHttpFields implements HttpFields {
    /** Singleton instance */
    static final EmptyHttpFields INSTANCE;
}

Usage Examples:

import org.eclipse.jetty.http.*;

// Create and manipulate mutable fields
MutableHttpFields headers = new MutableHttpFields();
headers.put(HttpHeader.CONTENT_TYPE, "application/json");
headers.add(HttpHeader.ACCEPT, "application/json");
headers.add(HttpHeader.ACCEPT, "text/plain");

// Access field values
String contentType = headers.get(HttpHeader.CONTENT_TYPE);
List<String> acceptValues = headers.getValuesList("Accept");

// Check field existence
boolean hasAuth = headers.contains(HttpHeader.AUTHORIZATION);
boolean hasJsonType = headers.contains("Content-Type", "application/json");

// Create immutable fields
ImmutableHttpFields immutable = ImmutableHttpFields.builder()
    .add(HttpHeader.USER_AGENT, "MyApp/1.0")
    .put(HttpHeader.CONNECTION, "keep-alive")
    .build();

// Work with individual fields
HttpField field = new HttpField(HttpHeader.CACHE_CONTROL, "max-age=3600, public");
boolean isPublic = field.contains("public");
String[] directives = field.getValues();

// Specialized integer/long fields for performance
HttpField contentLength = new LongValueHttpField(HttpHeader.CONTENT_LENGTH, 1024);
HttpField maxAge = new IntValueHttpField(HttpHeader.AGE, 300);

Install with Tessl CLI

npx tessl i tessl/maven-org-eclipse-jetty--jetty-http

docs

compression-utilities.md

content-management.md

http-headers.md

http-methods-status.md

http-parsing-generation.md

index.md

multipart-processing.md

path-mapping.md

uri-processing.md

tile.json