查看本类的 API文档回源码主页

   /*
    * 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
   * <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>.
   * @apiviz.exclude
   */
  public class HttpVersion implements Comparable<HttpVersion> {
  
      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
       * <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>.
       *
       * @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
      * <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>
      *
      * @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();
     }
 }