1 /*
2 * Copyright 2012 The Netty Project
3 *
4 * The Netty Project licenses this file to you under the Apache License,
5 * version 2.0 (the "License"); you may not use this file except in compliance
6 * with the 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.http;
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 * @apiviz.exclude
26 */
27 public class HttpMethod implements Comparable<HttpMethod> {
28 /**
29 * The OPTIONS method represents a request for information about the communication options
30 * available on the request/response chain identified by the Request-URI. This method allows
31 * the client to determine the options and/or requirements associated with a resource, or the
32 * capabilities of a server, without implying a resource action or initiating a resource
33 * retrieval.
34 */
35 public static final HttpMethod OPTIONS = new HttpMethod("OPTIONS");
36
37 /**
38 * The GET method means retrieve whatever information (in the form of an entity) is identified
39 * by the Request-URI. If the Request-URI refers to a data-producing process, it is the
40 * produced data which shall be returned as the entity in the response and not the source text
41 * of the process, unless that text happens to be the output of the process.
42 */
43 public static final HttpMethod GET = new HttpMethod("GET");
44
45 /**
46 * The HEAD method is identical to GET except that the server MUST NOT return a message-body in
47 * the response.
48 */
49 public static final HttpMethod HEAD = new HttpMethod("HEAD");
50
51 /**
52 * The POST method is used to request that the origin server accept the entity enclosed in the
53 * request as a new subordinate of the resource identified by the Request-URI in the
54 * Request-Line.
55 */
56 public static final HttpMethod POST = new HttpMethod("POST");
57
58 /**
59 * The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
60 */
61 public static final HttpMethod PUT = new HttpMethod("PUT");
62
63 /**
64 * The PATCH method requests that a set of changes described in the
65 * request entity be applied to the resource identified by the Request-URI.
66 */
67 public static final HttpMethod PATCH = new HttpMethod("PATCH");
68
69 /**
70 * The DELETE method requests that the origin server delete the resource identified by the
71 * 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
77 * message.
78 */
79 public static final HttpMethod TRACE = new HttpMethod("TRACE");
80
81 /**
82 * This specification reserves the method name CONNECT for use with a proxy that can
83 * dynamically switch to being a tunnel
84 */
85 public static final HttpMethod CONNECT = new HttpMethod("CONNECT");
86
87 private static final Map<String, HttpMethod> methodMap =
88 new HashMap<String, HttpMethod>();
89
90 static {
91 methodMap.put(OPTIONS.toString(), OPTIONS);
92 methodMap.put(GET.toString(), GET);
93 methodMap.put(HEAD.toString(), HEAD);
94 methodMap.put(POST.toString(), POST);
95 methodMap.put(PUT.toString(), PUT);
96 methodMap.put(PATCH.toString(), PATCH);
97 methodMap.put(DELETE.toString(), DELETE);
98 methodMap.put(TRACE.toString(), TRACE);
99 methodMap.put(CONNECT.toString(), CONNECT);
100 }
101
102 /**
103 * Returns the {@link HttpMethod} represented by the specified name.
104 * If the specified name is a standard HTTP method name, a cached instance
105 * will be returned. Otherwise, a new instance will be returned.
106 */
107 public static HttpMethod valueOf(String name) {
108 if (name == null) {
109 throw new NullPointerException("name");
110 }
111
112 name = name.trim();
113 if (name.length() == 0) {
114 throw new IllegalArgumentException("empty name");
115 }
116
117 HttpMethod result = methodMap.get(name);
118 if (result != null) {
119 return result;
120 } else {
121 return new HttpMethod(name);
122 }
123 }
124
125 private final String name;
126
127 /**
128 * Creates a new HTTP method with the specified name. You will not need to
129 * create a new method unless you are implementing a protocol derived from
130 * HTTP, such as
131 * <a href="http://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol">RTSP</a> and
132 * <a href="http://en.wikipedia.org/wiki/Internet_Content_Adaptation_Protocol">ICAP</a>
133 */
134 public HttpMethod(String name) {
135 if (name == null) {
136 throw new NullPointerException("name");
137 }
138
139 name = name.trim();
140 if (name.length() == 0) {
141 throw new IllegalArgumentException("empty name");
142 }
143
144 for (int i = 0; i < name.length(); i ++) {
145 if (Character.isISOControl(name.charAt(i)) ||
146 Character.isWhitespace(name.charAt(i))) {
147 throw new IllegalArgumentException("invalid character in name");
148 }
149 }
150
151 this.name = name;
152 }
153
154 /**
155 * Returns the name of this method.
156 */
157 public String getName() {
158 return name;
159 }
160
161 @Override
162 public int hashCode() {
163 return getName().hashCode();
164 }
165
166 @Override
167 public boolean equals(Object o) {
168 if (!(o instanceof HttpMethod)) {
169 return false;
170 }
171
172 HttpMethod that = (HttpMethod) o;
173 return getName().equals(that.getName());
174 }
175
176 @Override
177 public String toString() {
178 return getName();
179 }
180
181 public int compareTo(HttpMethod o) {
182 return getName().compareTo(o.getName());
183 }
184 }