public HttpVersion(int major,
    int minor) 
{
  
        if (major <  0) {
            throw new IllegalArgumentException("HTTP major version number may not be negative");
        }
        this.major = major;
        if (minor <  0) {
            throw new IllegalArgumentException("HTTP minor version number may not be negative");
        }
        this.minor = minor;
}

Create an HTTP protocol version designator.

Parameters:

major - the major version number of the HTTP protocol

minor - the minor version number of the HTTP protocol

Throws:

IllegalArgumentException - if either major or minor version number is negative

 public int compareTo(HttpVersion anotherVer) 
{
        if (anotherVer == null) {
            throw new IllegalArgumentException("Version parameter may not be null"); 
        }
        int delta = getMajor() - anotherVer.getMajor();
        if (delta == 0) {
            delta = getMinor() - anotherVer.getMinor();
        }
        return delta;
}

Compares this HTTP protocol version with another one.

 public int compareTo(Object o) 
{
        return compareTo((HttpVersion)o);
}

 public boolean equals(Object obj) 
{
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof HttpVersion)) {
            return false;
        }
        return equals((HttpVersion)obj);
}

 public boolean equals(HttpVersion version) 
{
        return compareTo(version) == 0;
}

Test if the HTTP protocol version is equal to the given number.

 public int getMajor() 
{
        return major;
}

Returns the major version number of the HTTP protocol.

 public int getMinor() 
{
        return minor;
}

Returns the minor version number of the HTTP protocol.

 public boolean greaterEquals(HttpVersion version) 
{
        return compareTo(version)  >= 0;
}

Test if the HTTP protocol version is greater or equal to the given number.

 public int hashCode() 
{
        return this.major * 100000 + this.minor;
}

 public boolean lessEquals(HttpVersion version) 
{
        return compareTo(version) < = 0;
}

Test if the HTTP protocol version is less or equal to the given number.

 public static HttpVersion parse(String s) throws ProtocolException 
{
        if (s == null) {
            throw new IllegalArgumentException("String may not be null");
        }
        if (!s.startsWith("HTTP/")) {
            throw new ProtocolException("Invalid HTTP version string: " + s);
        }
        int major, minor;
        int i1 = "HTTP/".length();
        int i2 = s.indexOf(".", i1);
        if (i2 == -1) {
            throw new ProtocolException("Invalid HTTP version number: " + s);
        }
        try {
            major = Integer.parseInt(s.substring(i1, i2)); 
        } catch (NumberFormatException e) {
            throw new ProtocolException("Invalid HTTP major version number: " + s);
        }
        i1 = i2 + 1;
        i2 = s.length();
        try {
            minor = Integer.parseInt(s.substring(i1, i2)); 
        } catch (NumberFormatException e) {
            throw new ProtocolException("Invalid HTTP minor version number: " + s);
        }
        return new HttpVersion(major, minor);
}

Parses the textual representation of the given HTTP protocol version.

 public String toString() 
{
        StringBuffer buffer = new StringBuffer();
        buffer.append("HTTP/"); 
        buffer.append(this.major); 
        buffer.append('."); 
        buffer.append(this.minor); 
        return buffer.toString();
}