model/ietf/ietf-type-util/src/main/java/org/opendaylight/mdsal/model/ietf/util/AbstractIetfInetUtil.java

   1 /*
   2  * Copyright (c) 2016 Pantheon Technologies s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.model.ietf.util;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.annotations.Beta;
  14 import com.google.common.net.InetAddresses;
  15 import java.net.Inet4Address;
  16 import java.net.Inet6Address;
  17 import java.net.InetAddress;
  18 import java.net.UnknownHostException;
  19 import java.util.AbstractMap.SimpleImmutableEntry;
  20 import java.util.Map.Entry;
  21 import org.eclipse.jdt.annotation.NonNull;
  22 import org.eclipse.jdt.annotation.Nullable;
  23 import org.opendaylight.mdsal.binding.spec.reflect.StringValueObjectFactory;
  24
  25 /**
  26  * A set of utility methods to efficiently instantiate various ietf-inet-types DTOs.
  27  */
  28 @Beta
  29 @SuppressWarnings("checkstyle:classTypeParameterName")
  30 public abstract class AbstractIetfInetUtil<A4, A4NZ extends A4, P4, A6, A6NZ extends A6, P6, A, ANZ, P> {
  31     private static final int INET4_LENGTH = 4;
  32     private static final int INET6_LENGTH = 16;
  33
  34     private final StringValueObjectFactory<A4NZ> address4NoZoneFactory;
  35     private final StringValueObjectFactory<P4> prefix4Factory;
  36     private final StringValueObjectFactory<A6NZ> address6NoZoneFactory;
  37     private final StringValueObjectFactory<P6> prefix6Factory;
  38     private final Class<A4NZ> addr4nzClass;
  39     private final Class<A6NZ> addr6nzClass;
  40
  41     protected AbstractIetfInetUtil(final Class<A4NZ> addr4nzClass, final Class<P4> prefix4Class,
  42             final Class<A6NZ> addr6nzClass, final Class<P6> prefix6Class) {
  43         this.addr4nzClass = requireNonNull(addr4nzClass);
  44         this.addr6nzClass = requireNonNull(addr6nzClass);
  45         this.address4NoZoneFactory = StringValueObjectFactory.create(addr4nzClass, "0.0.0.0");
  46         this.prefix4Factory = StringValueObjectFactory.create(prefix4Class, "0.0.0.0/0");
  47         this.address6NoZoneFactory = StringValueObjectFactory.create(addr6nzClass, "::0");
  48         this.prefix6Factory = StringValueObjectFactory.create(prefix6Class, "::0/0");
  49     }
  50
  51     protected abstract @NonNull A ipv4Address(@NonNull A4NZ addr);
  52
  53     protected abstract @NonNull ANZ ipv4AddressNoZone(@NonNull A4NZ addr);
  54
  55     protected abstract @NonNull A ipv6Address(@NonNull A6NZ addr);
  56
  57     protected abstract @NonNull ANZ ipv6AddressNoZone(@NonNull A6NZ addr);
  58
  59     protected abstract @Nullable A4 maybeIpv4Address(@NonNull A addr);
  60
  61     protected abstract @Nullable A4NZ maybeIpv4AddressNoZone(@NonNull ANZ addr);
  62
  63     protected abstract @Nullable A6 maybeIpv6Address(@NonNull A addr);
  64
  65     protected abstract @Nullable A6NZ maybeIpv6AddressNoZone(@NonNull ANZ addr);
  66
  67     protected abstract @NonNull P ipv4Prefix(@NonNull P4 addr);
  68
  69     protected abstract @NonNull P ipv6Prefix(@NonNull P6 addr);
  70
  71     protected abstract @NonNull String ipv4AddressString(@NonNull A4 addr);
  72
  73     protected abstract @NonNull String ipv6AddressString(@NonNull A6 addr);
  74
  75     protected abstract @NonNull String ipv4PrefixString(@NonNull P4 prefix);
  76
  77     protected abstract @NonNull String ipv6PrefixString(@NonNull P6 prefix);
  78
  79     /**
  80      * Create an IpAddress by interpreting input bytes as an IPv4 or IPv6 address, based on array length.
  81      *
  82      * @param bytes 4-byte (IPv4) or 6-byte (IPv6) array
  83      * @return An IpAddress object
  84      * @throws IllegalArgumentException if bytes has length different from 4 or 6
  85      * @throws NullPointerException if bytes is null
  86      */
  87     public final @NonNull A ipAddressFor(final byte @NonNull[] bytes) {
  88         switch (bytes.length) {
  89             case INET4_LENGTH:
  90                 return ipv4Address(ipv4AddressFor(bytes));
  91             case INET6_LENGTH:
  92                 return ipv6Address(ipv6AddressFor(bytes));
  93             default:
  94                 throw new IllegalArgumentException("Invalid array length " + bytes.length);
  95         }
  96     }
  97
  98     public final @NonNull A ipAddressFor(final @NonNull InetAddress addr) {
  99         requireNonNull(addr, "Address must not be null");
 100         if (addr instanceof Inet4Address) {
 101             return ipv4Address(ipv4AddressFor(addr));
 102         } else if (addr instanceof Inet6Address) {
 103             return ipv6Address(ipv6AddressFor(addr));
 104         } else {
 105             throw new IllegalArgumentException("Unhandled address " + addr);
 106         }
 107     }
 108
 109     /**
 110      * Create an IpAddress by interpreting input bytes as an IPv4 or IPv6 address, based on array length.
 111      *
 112      * @param bytes 4-byte (IPv4) or 6-byte (IPv6) array
 113      * @return A no-zone IpAddress object
 114      * @throws IllegalArgumentException if bytes has length different from 4 or 6
 115      * @throws NullPointerException if bytes is null
 116      */
 117     public final @NonNull ANZ ipAddressNoZoneFor(final byte @NonNull[] bytes) {
 118         switch (bytes.length) {
 119             case INET4_LENGTH:
 120                 return ipv4AddressNoZone(ipv4AddressFor(bytes));
 121             case INET6_LENGTH:
 122                 return ipv6AddressNoZone(ipv6AddressFor(bytes));
 123             default:
 124                 throw new IllegalArgumentException("Invalid array length " + bytes.length);
 125         }
 126     }
 127
 128     public final @NonNull ANZ ipAddressNoZoneFor(final @NonNull InetAddress addr) {
 129         requireNonNull(addr, "Address must not be null");
 130         if (addr instanceof Inet4Address) {
 131             return ipv4AddressNoZone(ipv4AddressFor(addr));
 132         } else if (addr instanceof Inet6Address) {
 133             return ipv6AddressNoZone(ipv6AddressFor(addr));
 134         } else {
 135             throw new IllegalArgumentException("Unhandled address " + addr);
 136         }
 137     }
 138
 139     /**
 140      * Create an IpPrefix by combining the address with a mask. The address
 141      * bytes are interpreted as an address and the specified mask is concatenated to
 142      * it. The address bytes are not masked.
 143      *
 144      * @param bytes Input address as a 4-byte (IPv4) or 16-byte (IPv6) array
 145      * @param mask Prefix mask
 146      * @return An IpPrefix object
 147      * @throws IllegalArgumentException if bytes has length different from 4 or 16 or if mask is not
 148      *         in range 0-32 or 0-128 respectively
 149      * @throws NullPointerException if bytes is null
 150      */
 151     public final @NonNull P ipPrefixFor(final byte @NonNull[] bytes, final int mask) {
 152         switch (bytes.length) {
 153             case INET4_LENGTH:
 154                 return ipv4Prefix(ipv4PrefixFor(bytes, mask));
 155             case INET6_LENGTH:
 156                 return ipv6Prefix(ipv6PrefixFor(bytes, mask));
 157             default:
 158                 throw new IllegalArgumentException("Invalid array length " + bytes.length);
 159         }
 160     }
 161
 162     public final @NonNull P ipPrefixFor(final @NonNull InetAddress addr, final int mask) {
 163         requireNonNull(addr, "Address must not be null");
 164         if (addr instanceof Inet4Address) {
 165             return ipv4Prefix(ipv4PrefixFor(addr, mask));
 166         } else if (addr instanceof Inet6Address) {
 167             return ipv6Prefix(ipv6PrefixFor(addr, mask));
 168         } else {
 169             throw new IllegalArgumentException("Unhandled address " + addr);
 170         }
 171     }
 172
 173     public final @NonNull InetAddress inetAddressFor(final @NonNull A addr) {
 174         final A4 v4 = maybeIpv4Address(addr);
 175         if (v4 != null) {
 176             return inet4AddressFor(v4);
 177         }
 178         final A6 v6 = maybeIpv6Address(addr);
 179         checkArgument(v6 != null, "Address %s is neither IPv4 nor IPv6", addr);
 180         return inet6AddressFor(v6);
 181     }
 182
 183     public final @NonNull InetAddress inetAddressForNoZone(final @NonNull ANZ addr) {
 184         final A4NZ v4 = maybeIpv4AddressNoZone(addr);
 185         if (v4 != null) {
 186             return inet4AddressForNoZone(v4);
 187         }
 188         final A6NZ v6 = maybeIpv6AddressNoZone(addr);
 189         checkArgument(v6 != null, "Address %s is neither IPv4 nor IPv6", addr);
 190         return inet6AddressForNoZone(v6);
 191     }
 192
 193
 194     public final @NonNull Inet4Address inet4AddressFor(final @NonNull A4 addr) {
 195         try {
 196             return (Inet4Address) InetAddress.getByAddress(ipv4AddressBytes(addr));
 197         } catch (UnknownHostException e) {
 198             throw new IllegalArgumentException("Invalid address " + addr, e);
 199         }
 200     }
 201
 202     public final @NonNull Inet4Address inet4AddressForNoZone(final @NonNull A4NZ addr) {
 203         try {
 204             return (Inet4Address) InetAddress.getByAddress(ipv4AddressNoZoneBytes(addr));
 205         } catch (UnknownHostException e) {
 206             throw new IllegalArgumentException("Invalid address " + addr, e);
 207         }
 208     }
 209
 210     public final @NonNull Inet6Address inet6AddressFor(final @NonNull A6 addr) {
 211         try {
 212             return (Inet6Address) InetAddress.getByAddress(ipv6AddressBytes(addr));
 213         } catch (UnknownHostException e) {
 214             throw new IllegalArgumentException("Invalid address " + addr, e);
 215         }
 216     }
 217
 218     public final @NonNull Inet6Address inet6AddressForNoZone(final @NonNull A6NZ addr) {
 219         try {
 220             return (Inet6Address) InetAddress.getByAddress(ipv6AddressNoZoneBytes(addr));
 221         } catch (UnknownHostException e) {
 222             throw new IllegalArgumentException("Invalid address " + addr, e);
 223         }
 224     }
 225
 226     /**
 227      * Create an Ipv4AddressNoZone by interpreting input bytes as an IPv4 address.
 228      *
 229      * @param bytes 4-byte array
 230      * @return An Ipv4AddressNoZone object
 231      * @throws IllegalArgumentException if bytes has length different from 4
 232      * @throws NullPointerException if bytes is null
 233      */
 234     public final @NonNull A4NZ ipv4AddressFor(final byte @NonNull[] bytes) {
 235         return address4NoZoneFactory.newInstance(addressStringV4(bytes));
 236     }
 237
 238     /**
 239      * Create an Ipv4AddressNoZone by interpreting an {@link Inet4Address}.
 240      *
 241      * @param addr An {@link Inet4Address}
 242      * @return An Ipv4AddressNoZone object
 243      * @throws IllegalArgumentException if addr is not an {@link Inet4Address}
 244      * @throws NullPointerException if addr is null
 245      */
 246     public final @NonNull A4NZ ipv4AddressFor(final @NonNull InetAddress addr) {
 247         return address4NoZoneFactory.newInstance(addressStringV4(addr));
 248     }
 249
 250     /**
 251      * Create an Ipv4AddressNoZone by interpreting input 32 bits as an IPv4 address in big-endian format.
 252      *
 253      * @param bits 32 bits, big endian
 254      * @return An Ipv4AddressNoZone object
 255      */
 256     public final @NonNull A4NZ ipv4AddressFor(final int bits) {
 257         return address4NoZoneFactory.newInstance(Ipv4Utils.addressString(bits));
 258     }
 259
 260     /**
 261      * Create an Ipv4AddressNoZone by interpreting input bytes as an IPv4 address.
 262      *
 263      * @param bytes 4-byte array
 264      * @return An Ipv4AddressNoZone object
 265      * @throws IllegalArgumentException if bytes has length different from 4
 266      * @throws NullPointerException if bytes is null
 267      * @deprecated Use {@link #ipv4AddressFor(byte[])} instead.
 268      */
 269     @Deprecated(forRemoval = true)
 270     public final @NonNull A4NZ ipv4AddressNoZoneFor(final byte @NonNull[] bytes) {
 271         return ipv4AddressFor(bytes);
 272     }
 273
 274     /**
 275      * Create an Ipv4AddressNoZone by interpreting an {@link Inet4Address}.
 276      *
 277      * @param addr An {@link Inet4Address}
 278      * @return An Ipv4AddressNoZone object
 279      * @throws IllegalArgumentException if addr is not an {@link Inet4Address}
 280      * @throws NullPointerException if addr is null
 281      * @deprecated Use {@link #ipv4AddressFor(InetAddress)} instead.
 282      */
 283     @Deprecated(forRemoval = true)
 284     public final @NonNull A4NZ ipv4AddressNoZoneFor(final @NonNull InetAddress addr) {
 285         return ipv4AddressFor(addr);
 286     }
 287
 288     /**
 289      * Create an Ipv4AddressNoZone by interpreting input 32 bits as an IPv4 address in big-endian format.
 290      *
 291      * @param bits 32 bits, big endian
 292      * @return An Ipv4AddressNoZone object
 293      * @deprecated Use {@link #ipv4AddressFor(int)} instead.
 294      */
 295     @Deprecated(forRemoval = true)
 296     public final @NonNull A4NZ ipv4AddressNoZoneFor(final int bits) {
 297         return ipv4AddressFor(bits);
 298     }
 299
 300     /**
 301      * Create an Ipv4AddressNoZone by interpreting an Ipv4Address.
 302      *
 303      * @param addr An Ipv4Address
 304      * @return An Ipv4AddressNoZone object
 305      * @throws NullPointerException if addr is null
 306      */
 307     public final @NonNull A4NZ ipv4AddressNoZoneFor(final @NonNull A4 addr) {
 308         requireNonNull(addr, "Address must not be null");
 309         return addr4nzClass.isInstance(addr) ? addr4nzClass.cast(addr)
 310                 : address4NoZoneFactory.newInstance(stripZone(ipv4AddressString(addr)));
 311     }
 312
 313     public final @NonNull A4NZ ipv4AddressFrom(final @NonNull P4 prefix) {
 314         return prefixToAddress(address4NoZoneFactory, ipv4PrefixString(prefix));
 315     }
 316
 317     @Deprecated(forRemoval = true)
 318     public final @NonNull A4NZ ipv4AddressNoZoneFrom(final @NonNull P4 prefix) {
 319         return ipv4AddressFrom(prefix);
 320     }
 321
 322     public final byte @NonNull[] ipv4AddressBytes(final @NonNull A4 addr) {
 323         /*
 324          * This implementation relies heavily on the input string having been validated to comply with
 325          * the Ipv4Address pattern, which may include a zone index.
 326          */
 327         final String str = ipv4AddressString(addr);
 328         final int percent = str.indexOf('%');
 329         return Ipv4Utils.addressBytes(str, percent == -1 ? str.length() : percent);
 330     }
 331
 332     public final int ipv4AddressBits(final @NonNull A4 addr) {
 333         final String str = ipv4AddressString(addr);
 334         final int percent = str.indexOf('%');
 335         return Ipv4Utils.addressBits(str, percent == -1 ? str.length() : percent);
 336     }
 337
 338     public final byte @NonNull[] ipv4AddressNoZoneBytes(final @NonNull A4NZ addr) {
 339         /*
 340          * This implementation relies heavily on the input string having been validated to comply with
 341          * the Ipv4AddressNoZone pattern, which must not include a zone index.
 342          */
 343         final String str = ipv4AddressString(addr);
 344         return Ipv4Utils.addressBytes(str, str.length());
 345     }
 346
 347     public final int ipv4AddressNoZoneBits(final @NonNull A4NZ addr) {
 348         final String str = ipv4AddressString(addr);
 349         return Ipv4Utils.addressBits(str, str.length());
 350     }
 351
 352     /**
 353      * Create a /32 Ipv4Prefix by interpreting input bytes as an IPv4 address.
 354      *
 355      * @param bytes four-byte array
 356      * @return An Ipv4Prefix object
 357      * @throws IllegalArgumentException if bytes has length different from 4
 358      * @throws NullPointerException if bytes is null
 359      */
 360     public final @NonNull P4 ipv4PrefixFor(final byte @NonNull[] bytes) {
 361         return prefix4Factory.newInstance(prefixStringV4(bytes));
 362     }
 363
 364     /**
 365      * Create a Ipv4Prefix by combining the address with a mask. The address
 366      * bytes are interpreted as an address and the specified mask is concatenated to
 367      * it. The address bytes are not masked, hence input <code>address = { 1, 2, 3, 4 }</code>
 368      * and <code>mask=24</code> will result in <code>1.2.3.4/24</code>.
 369      *
 370      * @param address Input address as a 4-byte array
 371      * @param mask Prefix mask
 372      * @return An Ipv4Prefix object
 373      * @throws IllegalArgumentException if bytes has length different from 4 or if mask is not in range 0-32
 374      * @throws NullPointerException if bytes is null
 375      */
 376     public final @NonNull P4 ipv4PrefixFor(final byte @NonNull[] address, final int mask) {
 377         return prefix4Factory.newInstance(prefixStringV4(address, mask));
 378     }
 379
 380     /**
 381      * Create a /32 Ipv4Prefix for an {@link Inet4Address}.
 382      *
 383      * @param addr An {@link Inet4Address}
 384      * @return An Ipv4Prefix object
 385      * @throws IllegalArgumentException if addr is not an Inet4Address
 386      * @throws NullPointerException if addr is null
 387      */
 388     public final @NonNull P4 ipv4PrefixFor(final @NonNull InetAddress addr) {
 389         return prefix4Factory.newInstance(addressStringV4(addr) + "/32");
 390     }
 391
 392     /**
 393      * Create a Ipv4Prefix by combining the address with a mask. The address bytes are not masked.
 394      *
 395      * @param addr An {@link Inet4Address}
 396      * @param mask Prefix mask
 397      * @return An Ipv4Prefix object
 398      * @throws IllegalArgumentException if addr is not an Inet4Address or if mask is not in range 0-32
 399      * @throws NullPointerException if addr is null
 400      */
 401     public final @NonNull P4 ipv4PrefixFor(final @NonNull InetAddress addr, final int mask) {
 402         return newIpv4Prefix(addressStringV4(addr), mask);
 403     }
 404
 405     public final @NonNull P4 ipv4PrefixFor(final @NonNull A4 addr) {
 406         requireNonNull(addr, "Address must not be null");
 407         return prefix4Factory.newInstance(stripZone(ipv4AddressString(addr)) + "/32");
 408     }
 409
 410     public final @NonNull P4 ipv4PrefixFor(final @NonNull A4 addr, final int mask) {
 411         requireNonNull(addr, "Address must not be null");
 412         return newIpv4Prefix(stripZone(ipv4AddressString(addr)), mask);
 413     }
 414
 415     public final @NonNull P4 ipv4PrefixForNoZone(final @NonNull A4NZ addr) {
 416         requireNonNull(addr, "Address must not be null");
 417         return prefix4Factory.newInstance(ipv4AddressString(addr) + "/32");
 418     }
 419
 420     public final @NonNull P4 ipv4PrefixForNoZone(final @NonNull A4NZ addr, final int mask) {
 421         requireNonNull(addr, "Address must not be null");
 422         return newIpv4Prefix(ipv4AddressString(addr), mask);
 423     }
 424
 425     public final @NonNull P4 ipv4PrefixForShort(final byte @NonNull[] address, final int mask) {
 426         if (mask == 0) {
 427             // Easy case, reuse the template
 428             return prefix4Factory.getTemplate();
 429         }
 430
 431         return v4PrefixForShort(address, 0, mask / Byte.SIZE + (mask % Byte.SIZE == 0 ? 0 : 1), mask);
 432     }
 433
 434     public final @NonNull P4 ipv4PrefixForShort(final byte @NonNull[] array, final int startOffset, final int mask) {
 435         if (mask == 0) {
 436             // Easy case, reuse the template
 437             return prefix4Factory.getTemplate();
 438         }
 439
 440         return v4PrefixForShort(array, startOffset, mask / Byte.SIZE + (mask % Byte.SIZE == 0 ? 0 : 1), mask);
 441     }
 442
 443     private static String stripZone(final String str) {
 444         final int percent = str.indexOf('%');
 445         return percent == -1 ? str : str.substring(0, percent);
 446     }
 447
 448     private @NonNull P4 newIpv4Prefix(final String addr, final int mask) {
 449         checkArgument(mask >= 0 && mask <= 32, "Invalid mask %s", mask);
 450         return prefix4Factory.newInstance(addr + '/' + mask);
 451     }
 452
 453     public final @NonNull Entry<A4NZ, Integer> splitIpv4Prefix(final @NonNull P4 prefix) {
 454         return splitPrefix(address4NoZoneFactory, ipv4PrefixString(prefix));
 455     }
 456
 457     @Deprecated(forRemoval = true)
 458     public final @NonNull Entry<A4NZ, Integer> splitIpv4PrefixNoZone(final @NonNull P4 prefix) {
 459         return splitIpv4Prefix(prefix);
 460     }
 461
 462     public final byte @NonNull[] ipv4PrefixToBytes(final @NonNull P4 prefix) {
 463         final String str = ipv4PrefixString(prefix);
 464         final int slash = str.lastIndexOf('/');
 465
 466         final byte[] bytes = new byte[INET4_LENGTH + 1];
 467         Ipv4Utils.fillIpv4Bytes(bytes, 0, str, 0, slash);
 468         bytes[INET4_LENGTH] = (byte)Integer.parseInt(str.substring(slash + 1), 10);
 469         return bytes;
 470     }
 471
 472     /**
 473      * Create an Ipv6Address by interpreting input bytes as an IPv6 address.
 474      *
 475      * @param bytes 16-byte array
 476      * @return An Ipv6Address object
 477      * @throws IllegalArgumentException if bytes has length different from 16
 478      * @throws NullPointerException if bytes is null
 479      */
 480     public final @NonNull A6NZ ipv6AddressFor(final byte @NonNull[] bytes) {
 481         return address6NoZoneFactory.newInstance(addressStringV6(bytes));
 482     }
 483
 484     /**
 485      * Create an Ipv6Address by interpreting an {@link Inet6Address}.
 486      *
 487      * @param addr An {@link Inet6Address}
 488      * @return An Ipv6Address object
 489      * @throws IllegalArgumentException if addr is not an {@link Inet6Address}
 490      * @throws NullPointerException if addr is null
 491      */
 492     public final @NonNull A6NZ ipv6AddressFor(final @NonNull InetAddress addr) {
 493         return address6NoZoneFactory.newInstance(addressStringV6(addr));
 494     }
 495
 496     /**
 497      * Create an Ipv6AddressNoZone by interpreting input bytes as an IPv6 address.
 498      *
 499      * @param bytes 16-byte array
 500      * @return An Ipv6Address object
 501      * @throws IllegalArgumentException if bytes has length different from 16
 502      * @throws NullPointerException if bytes is null
 503      * @deprecated Use {@link #ipv6AddressFor(byte[])} instead.
 504      */
 505     @Deprecated(forRemoval = true)
 506     public final @NonNull A6NZ ipv6AddressNoZoneFor(final byte @NonNull[] bytes) {
 507         return ipv6AddressFor(bytes);
 508     }
 509
 510     /**
 511      * Create an Ipv6AddressNoZone by interpreting an {@link Inet6Address}.
 512      *
 513      * @param addr An {@link Inet6Address}
 514      * @return An Ipv6AddressNoZone object
 515      * @throws IllegalArgumentException if addr is not an {@link Inet6Address}
 516      * @throws NullPointerException if addr is null
 517      * @deprecated Use {@link #ipv6AddressFor(InetAddress)} instead.
 518      */
 519     @Deprecated(forRemoval = true)
 520     public final @NonNull A6NZ ipv6AddressNoZoneFor(final @NonNull InetAddress addr) {
 521         return ipv6AddressFor(addr);
 522     }
 523
 524     /**
 525      * Create an Ipv6AddressNoZone by interpreting an Ipv6Address.
 526      *
 527      * @param addr An Ipv6Address
 528      * @return An Ipv6AddressNoZone object
 529      * @throws NullPointerException if addr is null
 530      */
 531     public final @NonNull A6NZ ipv6AddressNoZoneFor(final @NonNull A6 addr) {
 532         requireNonNull(addr, "Address must not be null");
 533         return addr6nzClass.isInstance(addr) ? addr6nzClass.cast(addr)
 534                 : address6NoZoneFactory.newInstance(stripZone(ipv6AddressString(addr)));
 535     }
 536
 537     public final @NonNull A6NZ ipv6AddressFrom(final @NonNull P6 prefix) {
 538         return prefixToAddress(address6NoZoneFactory, ipv6PrefixString(prefix));
 539     }
 540
 541     @Deprecated(forRemoval = true)
 542     public final @NonNull A6NZ ipv6AddressNoZoneFrom(final @NonNull P6 prefix) {
 543         return ipv6AddressFrom(prefix);
 544     }
 545
 546     public final byte @NonNull[] ipv6AddressBytes(final @NonNull A6 addr) {
 547         final String str = ipv6AddressString(addr);
 548         final int percent = str.indexOf('%');
 549         return ipv6StringBytes(str, percent == -1 ? str.length() : percent);
 550     }
 551
 552     public final byte @NonNull[] ipv6AddressNoZoneBytes(final @NonNull A6NZ addr) {
 553         final String str = ipv6AddressString(addr);
 554         return ipv6StringBytes(str, str.length());
 555     }
 556
 557     private static byte @NonNull[] ipv6StringBytes(final @NonNull String str, final int limit) {
 558         final byte[] bytes = new byte[INET6_LENGTH];
 559         Ipv6Utils.fillIpv6Bytes(bytes, str, limit);
 560         return bytes;
 561     }
 562
 563     /**
 564      * Create a /128 Ipv6Prefix by interpreting input bytes as an IPv6 address.
 565      *
 566      * @param bytes four-byte array
 567      * @return An Ipv6Prefix object
 568      * @throws IllegalArgumentException if bytes has length different from 16
 569      * @throws NullPointerException if bytes is null
 570      */
 571     public final @NonNull P6 ipv6PrefixFor(final byte @NonNull[] bytes) {
 572         return prefix6Factory.newInstance(addressStringV6(bytes) + "/128");
 573     }
 574
 575     /**
 576      * Create a Ipv6Prefix by combining the address with a mask. The address
 577      * bytes are interpreted as an address and the specified mask is concatenated to
 578      * it. The address bytes are not masked.
 579      *
 580      * @param address Input address as a 16-byte array
 581      * @param mask Prefix mask
 582      * @return An Ipv6Prefix object
 583      * @throws IllegalArgumentException if bytes has length different from 16 or if mask is not in range 0-128
 584      * @throws NullPointerException if bytes is null
 585      */
 586     public final @NonNull P6 ipv6PrefixFor(final byte @NonNull[] address, final int mask) {
 587         checkArgument(mask >= 0 && mask <= 128, "Invalid mask %s", mask);
 588         return prefix6Factory.newInstance(addressStringV6(address) + '/' + mask);
 589     }
 590
 591     /**
 592      * Create a /128 Ipv6Prefix by interpreting input bytes as an IPv6 address.
 593      *
 594      * @param addr an {@link Inet6Address}
 595      * @return An Ipv6Prefix object
 596      * @throws IllegalArgumentException if addr is not an Inet6Address
 597      * @throws NullPointerException if addr is null
 598      */
 599     public final @NonNull P6 ipv6PrefixFor(final @NonNull InetAddress addr) {
 600         return prefix6Factory.newInstance(addressStringV6(addr) + "/128");
 601     }
 602
 603     /**
 604      * Create a Ipv6Prefix by combining the address with a mask. The address
 605      * bytes are interpreted as an address and the specified mask is concatenated to
 606      * it. The address bytes are not masked.
 607      *
 608      * @param addr Input address
 609      * @param mask Prefix mask
 610      * @return An Ipv6Prefix object
 611      * @throws IllegalArgumentException if addr is not an Inet6Address or if mask is not in range 0-128
 612      * @throws NullPointerException if addr is null
 613      */
 614     public final @NonNull P6 ipv6PrefixFor(final @NonNull InetAddress addr, final int mask) {
 615         checkArgument(mask >= 0 && mask <= 128, "Invalid mask %s", mask);
 616         return prefix6Factory.newInstance(addressStringV6(addr) + '/' + mask);
 617     }
 618
 619     public final @NonNull P6 ipv6PrefixFor(final @NonNull A6 addr) {
 620         requireNonNull(addr, "Address must not be null");
 621         return prefix6Factory.newInstance(stripZone(ipv6AddressString(addr)) + "/128");
 622     }
 623
 624     public final @NonNull P6 ipv6PrefixFor(final @NonNull A6 addr, final int mask) {
 625         requireNonNull(addr, "Address must not be null");
 626         return newIpv6Prefix(stripZone(ipv6AddressString(addr)), mask);
 627     }
 628
 629     public final @NonNull P6 ipv6PrefixForNoZone(final @NonNull A6NZ addr) {
 630         requireNonNull(addr, "Address must not be null");
 631         return prefix6Factory.newInstance(ipv6AddressString(addr) + "/128");
 632     }
 633
 634     public final @NonNull P6 ipv6PrefixForNoZone(final @NonNull A6NZ addr, final int mask) {
 635         requireNonNull(addr, "Address must not be null");
 636         return newIpv6Prefix(ipv6AddressString(addr), mask);
 637     }
 638
 639     public final @NonNull P6 ipv6PrefixForShort(final byte @NonNull[] address, final int mask) {
 640         return ipv6PrefixForShort(address, 0, mask);
 641     }
 642
 643     public final @NonNull P6 ipv6PrefixForShort(final byte @NonNull[] array, final int startOffset, final int mask) {
 644         if (mask == 0) {
 645             // Easy case, reuse the template
 646             return prefix6Factory.getTemplate();
 647         }
 648
 649         checkArgument(mask > 0 && mask <= 128, "Invalid mask %s", mask);
 650         final int size = mask / Byte.SIZE + (mask % Byte.SIZE == 0 ? 0 : 1);
 651
 652         // Until we can instantiate an IPv6 address for a partial array, use a temporary buffer
 653         byte[] tmp = new byte[INET6_LENGTH];
 654         System.arraycopy(array, startOffset, tmp, 0, size);
 655         return ipv6PrefixFor(tmp, mask);
 656     }
 657
 658     private P6 newIpv6Prefix(final String addr, final int mask) {
 659         checkArgument(mask >= 0 && mask <= 128, "Invalid mask %s", mask);
 660         return prefix6Factory.newInstance(addr + '/' + mask);
 661     }
 662
 663     public final @NonNull Entry<A6NZ, Integer> splitIpv6Prefix(final @NonNull P6 prefix) {
 664         return splitPrefix(address6NoZoneFactory, ipv6PrefixString(prefix));
 665     }
 666
 667     @Deprecated(forRemoval = true)
 668     public final @NonNull Entry<A6NZ, Integer> splitIpv6PrefixNoZone(final @NonNull P6 prefix) {
 669         return splitIpv6Prefix(prefix);
 670     }
 671
 672     private static <T> @NonNull T prefixToAddress(final StringValueObjectFactory<T> factory, final String str) {
 673         return factory.newInstance(str.substring(0, str.lastIndexOf('/')));
 674     }
 675
 676     private static <T> @NonNull Entry<T, Integer> splitPrefix(final StringValueObjectFactory<T> factory,
 677             final String str) {
 678         final int slash = str.lastIndexOf('/');
 679         return new SimpleImmutableEntry<>(factory.newInstance(str.substring(0, slash)),
 680                 Integer.valueOf(str.substring(slash + 1)));
 681     }
 682
 683     public final byte @NonNull[] ipv6PrefixToBytes(final @NonNull P6 prefix) {
 684         final String str = ipv6PrefixString(prefix);
 685         final byte[] bytes = new byte[INET6_LENGTH + 1];
 686         final int slash = str.lastIndexOf('/');
 687         Ipv6Utils.fillIpv6Bytes(bytes, str, slash);
 688         bytes[INET6_LENGTH] = (byte)Integer.parseInt(str.substring(slash + 1), 10);
 689         return bytes;
 690     }
 691
 692     private static void appendIpv4String(final StringBuilder sb, final byte @NonNull[] bytes) {
 693         checkArgument(bytes.length == INET4_LENGTH, "IPv4 address length is 4 bytes");
 694
 695         sb.append(Byte.toUnsignedInt(bytes[0]));
 696         for (int i = 1; i < INET4_LENGTH; ++i) {
 697             sb.append('.').append(Byte.toUnsignedInt(bytes[i]));
 698         }
 699     }
 700
 701     static String addressStringV4(final byte @NonNull[] bytes) {
 702         final StringBuilder sb = new StringBuilder(15);
 703         appendIpv4String(sb, bytes);
 704         return sb.toString();
 705     }
 706
 707     private static @NonNull String addressStringV4(final InetAddress addr) {
 708         requireNonNull(addr, "Address must not be null");
 709         checkArgument(addr instanceof Inet4Address, "Address has to be an Inet4Address");
 710         return addr.getHostAddress();
 711     }
 712
 713     private static String addressStringV6(final byte @NonNull[] bytes) {
 714         checkArgument(bytes.length == INET6_LENGTH, "IPv6 address length is 16 bytes");
 715
 716         try {
 717             return addressStringV6(Inet6Address.getByAddress(null, bytes, null));
 718         } catch (UnknownHostException e) {
 719             throw new IllegalArgumentException(String.format("Invalid input %s", bytes), e);
 720         }
 721     }
 722
 723     private static String addressStringV6(final InetAddress addr) {
 724         requireNonNull(addr, "Address must not be null");
 725         checkArgument(addr instanceof Inet6Address, "Address has to be an Inet6Address");
 726         return addressStringV6((Inet6Address) addr);
 727     }
 728
 729     private static String addressStringV6(final Inet6Address addr) {
 730         return InetAddresses.toAddrString(addr);
 731     }
 732
 733     private static String prefixStringV4(final byte @NonNull[] bytes) {
 734         final StringBuilder sb = new StringBuilder(18);
 735         appendIpv4String(sb, bytes);
 736         return sb.append("/32").toString();
 737     }
 738
 739     private static String prefixStringV4(final byte @NonNull[] bytes, final int mask) {
 740         checkArgument(mask >= 0 && mask <= 32, "Invalid mask %s", mask);
 741
 742         final StringBuilder sb = new StringBuilder(18);
 743         appendIpv4String(sb, bytes);
 744         return sb.append('/').append(mask).toString();
 745     }
 746
 747     private P4 v4PrefixForShort(final byte @NonNull[] array, final int startOffset, final int size, final int mask) {
 748         if (startOffset == 0 && size == INET4_LENGTH && array.length == INET4_LENGTH) {
 749             // Easy case, fall back to non-short
 750             return ipv4PrefixFor(array, mask);
 751         }
 752
 753         final StringBuilder sb = new StringBuilder(18);
 754
 755         // Add from address
 756         sb.append(Byte.toUnsignedInt(array[startOffset]));
 757         for (int i = 1; i < size; i++) {
 758             sb.append('.').append(Byte.toUnsignedInt(array[startOffset + i]));
 759         }
 760
 761         // Add zeros
 762         for (int i = size; i < INET4_LENGTH; i++) {
 763             sb.append(".0");
 764         }
 765
 766         // Add mask
 767         checkArgument(mask > 0 && mask <= 32, "Invalid mask %s", mask);
 768         sb.append('/').append(mask);
 769
 770         return prefix4Factory.newInstance(sb.toString());
 771     }
 772 }