org.jboss.netty.handler.codec.http.HttpVersion Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of netty Show documentation
Show all versions of netty Show documentation
The Netty project is an effort to provide an asynchronous event-driven
network application framework and tools for rapid development of
maintainable high performance and high scalability protocol servers and
clients. In other words, Netty is a NIO client server framework which
enables quick and easy development of network applications such as protocol
servers and clients. It greatly simplifies and streamlines network
programming such as TCP and UDP socket server.
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package org.jboss.netty.handler.codec.http;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* The version of HTTP or its derived protocols, such as
* RTSP and
* ICAP.
* @apiviz.exclude
*/
public class HttpVersion implements Comparable {
private static final Pattern VERSION_PATTERN =
Pattern.compile("(\\S+)/(\\d+)\\.(\\d+)");
/**
* HTTP/1.0
*/
public static final HttpVersion HTTP_1_0 = new HttpVersion("HTTP", 1, 0, false);
/**
* HTTP/1.1
*/
public static final HttpVersion HTTP_1_1 = new HttpVersion("HTTP", 1, 1, true);
/**
* Returns an existing or new {@link HttpVersion} instance which matches to
* the specified protocol version string. If the specified {@code text} is
* equal to {@code "HTTP/1.0"}, {@link #HTTP_1_0} will be returned. If the
* specified {@code text} is equal to {@code "HTTP/1.1"}, {@link #HTTP_1_1}
* will be returned. Otherwise, a new {@link HttpVersion} instance will be
* returned.
*/
public static HttpVersion valueOf(String text) {
if (text == null) {
throw new NullPointerException("text");
}
text = text.trim().toUpperCase();
if ("HTTP/1.1".equals(text)) {
return HTTP_1_1;
}
if ("HTTP/1.0".equals(text)) {
return HTTP_1_0;
}
return new HttpVersion(text, true);
}
private final String protocolName;
private final int majorVersion;
private final int minorVersion;
private final String text;
private final boolean keepAliveDefault;
/**
* Creates a new HTTP version with the specified version string. You will
* not need to create a new instance unless you are implementing a protocol
* derived from HTTP, such as
* RTSP and
* ICAP.
*
* @param keepAliveDefault
* {@code true} if and only if the connection is kept alive unless
* the {@code "Connection"} header is set to {@code "close"} explicitly.
*/
public HttpVersion(String text, boolean keepAliveDefault) {
if (text == null) {
throw new NullPointerException("text");
}
text = text.trim().toUpperCase();
if (text.length() == 0) {
throw new IllegalArgumentException("empty text");
}
Matcher m = VERSION_PATTERN.matcher(text);
if (!m.matches()) {
throw new IllegalArgumentException("invalid version format: " + text);
}
protocolName = m.group(1);
majorVersion = Integer.parseInt(m.group(2));
minorVersion = Integer.parseInt(m.group(3));
this.text = protocolName + '/' + majorVersion + '.' + minorVersion;
this.keepAliveDefault = keepAliveDefault;
}
/**
* Creates a new HTTP version with the specified protocol name and version
* numbers. You will not need to create a new instance unless you are
* implementing a protocol derived from HTTP, such as
* RTSP and
* ICAP
*
* @param keepAliveDefault
* {@code true} if and only if the connection is kept alive unless
* the {@code "Connection"} header is set to {@code "close"} explicitly.
*/
public HttpVersion(
String protocolName, int majorVersion, int minorVersion,
boolean keepAliveDefault) {
if (protocolName == null) {
throw new NullPointerException("protocolName");
}
protocolName = protocolName.trim().toUpperCase();
if (protocolName.length() == 0) {
throw new IllegalArgumentException("empty protocolName");
}
for (int i = 0; i < protocolName.length(); i ++) {
if (Character.isISOControl(protocolName.charAt(i)) ||
Character.isWhitespace(protocolName.charAt(i))) {
throw new IllegalArgumentException("invalid character in protocolName");
}
}
if (majorVersion < 0) {
throw new IllegalArgumentException("negative majorVersion");
}
if (minorVersion < 0) {
throw new IllegalArgumentException("negative minorVersion");
}
this.protocolName = protocolName;
this.majorVersion = majorVersion;
this.minorVersion = minorVersion;
text = protocolName + '/' + majorVersion + '.' + minorVersion;
this.keepAliveDefault = keepAliveDefault;
}
/**
* Returns the name of the protocol such as {@code "HTTP"} in {@code "HTTP/1.0"}.
*/
public String getProtocolName() {
return protocolName;
}
/**
* Returns the name of the protocol such as {@code 1} in {@code "HTTP/1.0"}.
*/
public int getMajorVersion() {
return majorVersion;
}
/**
* Returns the name of the protocol such as {@code 0} in {@code "HTTP/1.0"}.
*/
public int getMinorVersion() {
return minorVersion;
}
/**
* Returns the full protocol version text such as {@code "HTTP/1.0"}.
*/
public String getText() {
return text;
}
/**
* Returns {@code true} if and only if the connection is kept alive unless
* the {@code "Connection"} header is set to {@code "close"} explicitly.
*/
public boolean isKeepAliveDefault() {
return keepAliveDefault;
}
/**
* Returns the full protocol version text such as {@code "HTTP/1.0"}.
*/
@Override
public String toString() {
return getText();
}
@Override
public int hashCode() {
return (getProtocolName().hashCode() * 31 + getMajorVersion()) * 31 +
getMinorVersion();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof HttpVersion)) {
return false;
}
HttpVersion that = (HttpVersion) o;
return getMinorVersion() == that.getMinorVersion() &&
getMajorVersion() == that.getMajorVersion() &&
getProtocolName().equals(that.getProtocolName());
}
public int compareTo(HttpVersion o) {
int v = getProtocolName().compareTo(o.getProtocolName());
if (v != 0) {
return v;
}
v = getMajorVersion() - o.getMajorVersion();
if (v != 0) {
return v;
}
return getMinorVersion() - o.getMinorVersion();
}
}