com.google.common.net

## Class HostAndPort

- java.lang.Object
- - com.google.common.net.HostAndPort

- All Implemented Interfaces:
    java.io.Serializable

      @Beta
      @Immutable
      @GwtCompatible
      public final class HostAndPort
      extends java.lang.Object
      implements java.io.Serializable

  An immutable representation of a host and port.

  Example usage:

       HostAndPort hp = HostAndPort.fromString("[2001:db8::1]")
           .withDefaultPort(80)
           .requireBracketsForIPv6();
       hp.getHostText();  // returns "2001:db8::1"
       hp.getPort();      // returns 80
       hp.toString();     // returns "[2001:db8::1]:80"

  Here are some examples of recognized formats:

  - example.com
  - example.com:80
  - 192.0.2.1
  - 192.0.2.1:80
  - [2001:db8::1] - `getHostText()` omits brackets
  - [2001:db8::1]:80 - `getHostText()` omits brackets
  - 2001:db8::1 - Use `requireBracketsForIPv6()` to prohibit this

  Note that this is not an exhaustive list, because these methods are only concerned with brackets, colons, and port numbers. Full validation of the host field (if desired) is the caller's responsibility.

  Since:
    10.0
  See Also:
    Serialized Form

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `equals(java.lang.Object other)`
    `static HostAndPort` | `fromHost(java.lang.String host)` Build a HostAndPort instance from a host only.
    `static HostAndPort` | `fromParts(java.lang.String host, int port)` Build a HostAndPort instance from separate host and port values.
    `static HostAndPort` | `fromString(java.lang.String hostPortString)` Split a freeform string into a host and port, without strict validation.
    `java.lang.String` | `getHostText()` Returns the portion of this `HostAndPort` instance that should represent the hostname or IPv4/IPv6 literal.
    `int` | `getPort()` Get the current port number, failing if no port is defined.
    `int` | `getPortOrDefault(int defaultPort)` Returns the current port number, with a default if no port is defined.
    `int` | `hashCode()`
    `boolean` | `hasPort()` Return true if this instance has a defined port.
    `HostAndPort` | `requireBracketsForIPv6()` Generate an error if the host might be a non-bracketed IPv6 literal.
    `java.lang.String` | `toString()` Rebuild the host:port string, including brackets if necessary.
    `HostAndPort` | `withDefaultPort(int defaultPort)` Provide a default port if the parsed string contained only a host.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Method Detail

    - #### getHostText

          public java.lang.String getHostText()

      Returns the portion of this `HostAndPort` instance that should represent the hostname or IPv4/IPv6 literal.

      A successful parse does not imply any degree of sanity in this field. For additional validation, see the `HostSpecifier` class.

    - #### hasPort

          public boolean hasPort()

      Return true if this instance has a defined port.

    - #### getPort

          public int getPort()

      Get the current port number, failing if no port is defined.
      Returns:
        a validated port number, in the range [0..65535]
      Throws:
        `java.lang.IllegalStateException` - if no port is defined. You can use `withDefaultPort(int)` to prevent this from occurring.

    - #### getPortOrDefault

          public int getPortOrDefault(int defaultPort)

      Returns the current port number, with a default if no port is defined.

    - #### fromParts

          public static HostAndPort fromParts(java.lang.String host,
                              int port)

      Build a HostAndPort instance from separate host and port values.

      Note: Non-bracketed IPv6 literals are allowed. Use `requireBracketsForIPv6()` to prohibit these.

      Parameters:
        `host` - the host string to parse. Must not contain a port number.
        `port` - a port number from [0..65535]
      Returns:
        if parsing was successful, a populated HostAndPort object.
      Throws:
        `java.lang.IllegalArgumentException` - if `host` contains a port number, or `port` is out of range.

    - #### fromHost

          public static HostAndPort fromHost(java.lang.String host)

      Build a HostAndPort instance from a host only.

      Note: Non-bracketed IPv6 literals are allowed. Use `requireBracketsForIPv6()` to prohibit these.

      Parameters:
        `host` - the host-only string to parse. Must not contain a port number.
      Returns:
        if parsing was successful, a populated HostAndPort object.
      Throws:
        `java.lang.IllegalArgumentException` - if `host` contains a port number.
      Since:
        17.0

    - #### fromString

          public static HostAndPort fromString(java.lang.String hostPortString)

      Split a freeform string into a host and port, without strict validation. Note that the host-only formats will leave the port field undefined. You can use `withDefaultPort(int)` to patch in a default value.
      Parameters:
        `hostPortString` - the input string to parse.
      Returns:
        if parsing was successful, a populated HostAndPort object.
      Throws:
        `java.lang.IllegalArgumentException` - if nothing meaningful could be parsed.

    - #### withDefaultPort

          public HostAndPort withDefaultPort(int defaultPort)

      Provide a default port if the parsed string contained only a host. You can chain this after `fromString(String)` to include a port in case the port was omitted from the input string. If a port was already provided, then this method is a no-op.
      Parameters:
        `defaultPort` - a port number, from [0..65535]
      Returns:
        a HostAndPort instance, guaranteed to have a defined port.

    - #### requireBracketsForIPv6

          public HostAndPort requireBracketsForIPv6()

      Generate an error if the host might be a non-bracketed IPv6 literal.

      URI formatting requires that IPv6 literals be surrounded by brackets, like "[2001:db8::1]". Chain this call after `fromString(String)` to increase the strictness of the parser, and disallow IPv6 literals that don't contain these brackets.

      Note that this parser identifies IPv6 literals solely based on the presence of a colon. To perform actual validation of IP addresses, see the `InetAddresses.forString(String)` method.

      Returns:
        `this`, to enable chaining of calls.
      Throws:
        `java.lang.IllegalArgumentException` - if bracketless IPv6 is detected.

    - #### equals

          public boolean equals(@Nullable
                       java.lang.Object other)

      Overrides:
        `equals` in class `java.lang.Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `java.lang.Object`

    - #### toString

          public java.lang.String toString()

      Rebuild the host:port string, including brackets if necessary.
      Overrides:
        `toString` in class `java.lang.Object`