1 /*
2 * Copyright 2009 Red Hat, Inc.
3 *
4 * Red Hat licenses this file to you under the Apache License, version 2.0
5 * (the "License"); you may not use this file except in compliance with the
6 * License. You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
14 * under the License.
15 */
16 package org.jboss.netty.handler.codec.http2;
17
18 import java.util.HashMap;
19 import java.util.Map;
20
21 /**
22 * The request method of HTTP or its derived protocols, such as
23 * <a href="http://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol">RTSP</a> and
24 * <a href="http://en.wikipedia.org/wiki/Internet_Content_Adaptation_Protocol">ICAP</a>.
25 *
26 * @author <a href="http://www.jboss.org/netty/">The Netty Project</a>
27 * @author Andy Taylor (andy.taylor@jboss.org)
28 * @version $Rev: 619 $, $Date: 2010-11-11 20:30:06 +0100 (jeu., 11 nov. 2010) $
29 *
30 * @apiviz.exclude
31 */
32 public class HttpMethod implements Comparable<HttpMethod> {
33 /**
34 * The OPTIONS method represents a request for information about the communication options available on the request/response
35 * chain identified by the Request-URI. This method allows the client to determine the options and/or requirements
36 * associated with a resource, or the capabilities of a server, without implying a resource action or initiating a
37 * resource retrieval.
38 */
39 public static final HttpMethod OPTIONS = new HttpMethod("OPTIONS");
40
41 /**
42 * The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.
43 * If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity
44 * in the response and not the source text of the process, unless that text happens to be the output of the process.
45 */
46 public static final HttpMethod GET = new HttpMethod("GET");
47
48 /**
49 * The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response.
50 */
51 public static final HttpMethod HEAD = new HttpMethod("HEAD");
52
53 /**
54 * The POST method is used to request that the origin server accept the entity enclosed in the request as a new
55 * subordinate of the resource identified by the Request-URI in the Request-Line.
56 */
57 public static final HttpMethod POST = new HttpMethod("POST");
58
59 /**
60 * The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
61 */
62 public static final HttpMethod PUT = new HttpMethod("PUT");
63
64 /**
65 * The PATCH method requests that a set of changes described in the
66 * request entity be applied to the resource identified by the Request-URI.
67 */
68 public static final HttpMethod PATCH = new HttpMethod("PATCH");
69
70 /**
71 * The DELETE method requests that the origin server delete the resource identified by the Request-URI.
72 */
73 public static final HttpMethod DELETE = new HttpMethod("DELETE");
74
75 /**
76 * The TRACE method is used to invoke a remote, application-layer loop- back of the request message.
77 */
78 public static final HttpMethod TRACE = new HttpMethod("TRACE");
79
80 /**
81 * This specification reserves the method name CONNECT for use with a proxy that can dynamically switch to being a tunnel
82 */
83 public static final HttpMethod CONNECT = new HttpMethod("CONNECT");
84
85 private static final Map<String, HttpMethod> methodMap =
86 new HashMap<String, HttpMethod>();
87
88 static {
89 methodMap.put(OPTIONS.toString(), OPTIONS);
90 methodMap.put(GET.toString(), GET);
91 methodMap.put(HEAD.toString(), HEAD);
92 methodMap.put(POST.toString(), POST);
93 methodMap.put(PUT.toString(), PUT);
94 methodMap.put(PATCH.toString(), PATCH);
95 methodMap.put(DELETE.toString(), DELETE);
96 methodMap.put(TRACE.toString(), TRACE);
97 methodMap.put(CONNECT.toString(), CONNECT);
98 }
99
100 /**
101 * Returns the {@link HttpMethod} represented by the specified name.
102 * If the specified name is a standard HTTP method name, a cached instance
103 * will be returned. Otherwise, a new instance will be returned.
104 */
105 public static HttpMethod valueOf(String name) {
106 if (name == null) {
107 throw new NullPointerException("name");
108 }
109
110 name = name.trim().toUpperCase();
111 if (name.length() == 0) {
112 throw new IllegalArgumentException("empty name");
113 }
114
115 HttpMethod result = methodMap.get(name);
116 if (result != null) {
117 return result;
118 } else {
119 return new HttpMethod(name);
120 }
121 }
122
123 private final String name;
124
125 /**
126 * Creates a new HTTP method with the specified name. You will not need to
127 * create a new method unless you are implementing a protocol derived from
128 * HTTP, such as
129 * <a href="http://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol">RTSP</a> and
130 * <a href="http://en.wikipedia.org/wiki/Internet_Content_Adaptation_Protocol">ICAP</a>
131 */
132 public HttpMethod(String name) {
133 if (name == null) {
134 throw new NullPointerException("name");
135 }
136
137 name = name.trim().toUpperCase();
138 if (name.length() == 0) {
139 throw new IllegalArgumentException("empty name");
140 }
141
142 for (int i = 0; i < name.length(); i ++) {
143 if (Character.isISOControl(name.charAt(i)) ||
144 Character.isWhitespace(name.charAt(i))) {
145 throw new IllegalArgumentException("invalid character in name");
146 }
147 }
148
149 this.name = name;
150 }
151
152 /**
153 * Returns the name of this method.
154 */
155 public String getName() {
156 return name;
157 }
158
159 @Override
160 public int hashCode() {
161 return getName().hashCode();
162 }
163
164 @Override
165 public boolean equals(Object o) {
166 if (!(o instanceof HttpMethod)) {
167 return false;
168 }
169
170 HttpMethod that = (HttpMethod) o;
171 return getName().equals(that.getName());
172 }
173
174 @Override
175 public String toString() {
176 return getName();
177 }
178
179 public int compareTo(HttpMethod o) {
180 return getName().compareTo(o.getName());
181 }
182 }