2008-11-19 08:22:15 +01:00
|
|
|
/*
|
2011-12-09 06:18:34 +01:00
|
|
|
* Copyright 2011 The Netty Project
|
2009-06-19 19:48:17 +02:00
|
|
|
*
|
2011-12-09 06:18:34 +01:00
|
|
|
* 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:
|
2008-11-19 08:22:15 +01:00
|
|
|
*
|
2011-12-09 06:18:34 +01:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2008-11-19 08:22:15 +01:00
|
|
|
*
|
2009-08-28 09:15:49 +02:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
2011-12-09 06:18:34 +01:00
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
2009-08-28 09:15:49 +02:00
|
|
|
* License for the specific language governing permissions and limitations
|
|
|
|
* under the License.
|
2008-11-19 08:22:15 +01:00
|
|
|
*/
|
2011-12-09 04:38:59 +01:00
|
|
|
package io.netty.handler.codec.http;
|
2008-11-19 08:22:15 +01:00
|
|
|
|
2008-12-05 02:58:38 +01:00
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.Map;
|
|
|
|
|
2008-11-19 08:22:15 +01:00
|
|
|
/**
|
2009-06-19 17:01:47 +02:00
|
|
|
* The request method of HTTP or its derived protocols, such as
|
2009-06-19 16:15:20 +02:00
|
|
|
* <a href="http://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol">RTSP</a> and
|
|
|
|
* <a href="http://en.wikipedia.org/wiki/Internet_Content_Adaptation_Protocol">ICAP</a>.
|
2008-12-03 10:00:29 +01:00
|
|
|
* @apiviz.exclude
|
2008-11-19 08:22:15 +01:00
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public class HttpMethod implements Comparable<HttpMethod> {
|
2008-11-19 08:22:15 +01:00
|
|
|
/**
|
|
|
|
* The OPTIONS method represents a request for information about the communication options available on the request/response
|
|
|
|
* chain identified by the Request-URI. This method allows the client to determine the options and/or requirements
|
|
|
|
* associated with a resource, or the capabilities of a server, without implying a resource action or initiating a
|
|
|
|
* resource retrieval.
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod OPTIONS = new HttpMethod("OPTIONS");
|
2008-11-19 08:22:15 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.
|
|
|
|
* If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity
|
|
|
|
* in the response and not the source text of the process, unless that text happens to be the output of the process.
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod GET = new HttpMethod("GET");
|
2008-11-19 08:22:15 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response.
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod HEAD = new HttpMethod("HEAD");
|
2008-11-19 08:22:15 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The POST method is used to request that the origin server accept the entity enclosed in the request as a new
|
|
|
|
* subordinate of the resource identified by the Request-URI in the Request-Line.
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod POST = new HttpMethod("POST");
|
2008-11-19 08:22:15 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod PUT = new HttpMethod("PUT");
|
2008-11-19 08:22:15 +01:00
|
|
|
|
2009-12-16 08:23:35 +01:00
|
|
|
/**
|
|
|
|
* The PATCH method requests that a set of changes described in the
|
|
|
|
* request entity be applied to the resource identified by the Request-URI.
|
|
|
|
*/
|
|
|
|
public static final HttpMethod PATCH = new HttpMethod("PATCH");
|
|
|
|
|
2008-11-19 08:22:15 +01:00
|
|
|
/**
|
|
|
|
* The DELETE method requests that the origin server delete the resource identified by the Request-URI.
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod DELETE = new HttpMethod("DELETE");
|
2008-11-19 08:22:15 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The TRACE method is used to invoke a remote, application-layer loop- back of the request message.
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod TRACE = new HttpMethod("TRACE");
|
2008-11-19 08:22:15 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This specification reserves the method name CONNECT for use with a proxy that can dynamically switch to being a tunnel
|
|
|
|
*/
|
2008-12-05 02:58:38 +01:00
|
|
|
public static final HttpMethod CONNECT = new HttpMethod("CONNECT");
|
|
|
|
|
|
|
|
private static final Map<String, HttpMethod> methodMap =
|
|
|
|
new HashMap<String, HttpMethod>();
|
|
|
|
|
|
|
|
static {
|
|
|
|
methodMap.put(OPTIONS.toString(), OPTIONS);
|
|
|
|
methodMap.put(GET.toString(), GET);
|
|
|
|
methodMap.put(HEAD.toString(), HEAD);
|
|
|
|
methodMap.put(POST.toString(), POST);
|
|
|
|
methodMap.put(PUT.toString(), PUT);
|
2009-12-16 08:23:35 +01:00
|
|
|
methodMap.put(PATCH.toString(), PATCH);
|
2008-12-05 02:58:38 +01:00
|
|
|
methodMap.put(DELETE.toString(), DELETE);
|
|
|
|
methodMap.put(TRACE.toString(), TRACE);
|
|
|
|
methodMap.put(CONNECT.toString(), CONNECT);
|
|
|
|
}
|
|
|
|
|
2009-06-19 16:15:20 +02:00
|
|
|
/**
|
|
|
|
* Returns the {@link HttpMethod} represented by the specified name.
|
|
|
|
* If the specified name is a standard HTTP method name, a cached instance
|
|
|
|
* will be returned. Otherwise, a new instance will be returned.
|
|
|
|
*/
|
2009-02-11 10:24:28 +01:00
|
|
|
public static HttpMethod valueOf(String name) {
|
|
|
|
if (name == null) {
|
|
|
|
throw new NullPointerException("name");
|
2008-12-05 02:58:38 +01:00
|
|
|
}
|
|
|
|
|
2009-02-11 10:24:28 +01:00
|
|
|
name = name.trim().toUpperCase();
|
|
|
|
if (name.length() == 0) {
|
|
|
|
throw new IllegalArgumentException("empty name");
|
|
|
|
}
|
|
|
|
|
|
|
|
HttpMethod result = methodMap.get(name);
|
2008-12-05 02:58:38 +01:00
|
|
|
if (result != null) {
|
|
|
|
return result;
|
|
|
|
} else {
|
2009-02-11 10:24:28 +01:00
|
|
|
return new HttpMethod(name);
|
2008-12-05 02:58:38 +01:00
|
|
|
}
|
|
|
|
}
|
2008-11-19 08:22:15 +01:00
|
|
|
|
2009-02-11 10:24:28 +01:00
|
|
|
private final String name;
|
2008-11-19 08:22:15 +01:00
|
|
|
|
2009-06-19 16:15:20 +02:00
|
|
|
/**
|
2009-06-19 17:01:47 +02:00
|
|
|
* Creates a new HTTP method with the specified name. You will not need to
|
|
|
|
* create a new method unless you are implementing a protocol derived from
|
|
|
|
* HTTP, such as
|
2009-06-19 16:15:20 +02:00
|
|
|
* <a href="http://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol">RTSP</a> and
|
|
|
|
* <a href="http://en.wikipedia.org/wiki/Internet_Content_Adaptation_Protocol">ICAP</a>
|
|
|
|
*/
|
2009-02-11 10:24:28 +01:00
|
|
|
public HttpMethod(String name) {
|
|
|
|
if (name == null) {
|
|
|
|
throw new NullPointerException("name");
|
2008-12-05 02:58:38 +01:00
|
|
|
}
|
|
|
|
|
2009-02-11 10:24:28 +01:00
|
|
|
name = name.trim().toUpperCase();
|
|
|
|
if (name.length() == 0) {
|
|
|
|
throw new IllegalArgumentException("empty name");
|
|
|
|
}
|
2008-12-05 02:58:38 +01:00
|
|
|
|
2009-02-11 10:24:28 +01:00
|
|
|
for (int i = 0; i < name.length(); i ++) {
|
2009-02-12 06:02:22 +01:00
|
|
|
if (Character.isISOControl(name.charAt(i)) ||
|
|
|
|
Character.isWhitespace(name.charAt(i))) {
|
|
|
|
throw new IllegalArgumentException("invalid character in name");
|
2009-02-11 10:24:28 +01:00
|
|
|
}
|
2008-12-05 02:58:38 +01:00
|
|
|
}
|
2008-11-19 08:22:15 +01:00
|
|
|
|
2009-02-11 10:24:28 +01:00
|
|
|
this.name = name;
|
|
|
|
}
|
|
|
|
|
2009-06-19 16:15:20 +02:00
|
|
|
/**
|
|
|
|
* Returns the name of this method.
|
|
|
|
*/
|
2009-02-11 10:24:28 +01:00
|
|
|
public String getName() {
|
|
|
|
return name;
|
2008-11-19 08:22:15 +01:00
|
|
|
}
|
|
|
|
|
2008-12-05 02:58:38 +01:00
|
|
|
@Override
|
|
|
|
public int hashCode() {
|
2009-02-11 10:24:28 +01:00
|
|
|
return getName().hashCode();
|
2008-12-05 02:58:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean equals(Object o) {
|
|
|
|
if (!(o instanceof HttpMethod)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
HttpMethod that = (HttpMethod) o;
|
2009-02-11 10:24:28 +01:00
|
|
|
return getName().equals(that.getName());
|
2008-12-05 02:58:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String toString() {
|
2009-02-11 10:24:28 +01:00
|
|
|
return getName();
|
2008-11-19 08:22:15 +01:00
|
|
|
}
|
2008-12-05 02:58:38 +01:00
|
|
|
|
2010-11-12 01:45:39 +01:00
|
|
|
@Override
|
2008-12-05 02:58:38 +01:00
|
|
|
public int compareTo(HttpMethod o) {
|
2009-02-11 10:24:28 +01:00
|
|
|
return getName().compareTo(o.getName());
|
2008-12-05 02:58:38 +01:00
|
|
|
}
|
2008-11-19 08:22:15 +01:00
|
|
|
}
|