BUG-2825: Cleanup comments

[mdsal.git] / model / ietf / ietf-type-util / src / main / java / org / opendaylight / mdsal / model / ietf / util / Ipv6Utils.java

diff --git a/model/ietf/ietf-type-util/src/main/java/org/opendaylight/mdsal/model/ietf/util/Ipv6Utils.java b/model/ietf/ietf-type-util/src/main/java/org/opendaylight/mdsal/model/ietf/util/Ipv6Utils.java
index 4fdedf44a84855ebbd76c8e555a4aae5137039a0..ce35e413497987f32c2d19d8a17d1228be1728d1 100644 (file)
--- a/model/ietf/ietf-type-util/src/main/java/org/opendaylight/mdsal/model/ietf/util/Ipv6Utils.java
+++ b/model/ietf/ietf-type-util/src/main/java/org/opendaylight/mdsal/model/ietf/util/Ipv6Utils.java
@@ -9,9 +9,6 @@ package org.opendaylight.mdsal.model.ietf.util;
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Verify;
-import com.google.common.net.InetAddresses;
-import java.net.Inet4Address;
-import java.net.InetAddress;
 import javax.annotation.Nonnull;
 
 /**
@@ -56,46 +53,41 @@ final class Ipv6Utils {
     /**
      * Convert Ipv6Address object to a valid Canonical v6 address in byte format
      *
-     * @param ipv6Address - v6 Address object
-     *
-     * FIXME: rovarga: this looks wrong
-     * @return - byte array of size 16. Last byte contains netmask
-     *
+     * @param addrStr IPv6 address string
+     * @return byte array of size 16 containing the binary IPv6 address
      * @throws NullPointerException if ipv6address is null
      */
-   public static @Nonnull byte[] bytesForString(final @Nonnull String ipv6Address) {
-       final int percentPos = ipv6Address.indexOf('%');
-       // FIXME: do not perform a copy, just set the limit here.
-       final String address = percentPos == -1 ? ipv6Address : ipv6Address.substring(0, percentPos);
+   public static @Nonnull byte[] bytesForString(final @Nonnull String addrStr) {
+       final int percentPos = addrStr.indexOf('%');
+       final int addrStrLen = percentPos == -1 ? addrStr.length() : percentPos;
 
-       /* Leading :: requires some special handling. */
+       // Leading :: requires some special handling.
        int i = 0;
-       if (address.charAt(i) == ':') {
+       if (addrStr.charAt(i) == ':') {
            // Note ++i side-effect in check
-           Preconditions.checkArgument(address.charAt(++i) == ':', "Invalid v6 address '%s'", ipv6Address);
+           Preconditions.checkArgument(addrStr.charAt(++i) == ':', "Invalid v6 address '%s'", addrStr);
        }
 
        final byte[] dst = new byte[INADDR6SZ];
 
-       final int src_length = address.length();
        boolean saw_xdigit = false;
        int val = 0;
        int colonp = -1;
        int j = 0;
        int curtok = i;
-       while (i < src_length) {
-           final char ch = address.charAt(i++);
+       while (i < addrStrLen) {
+           final char ch = addrStr.charAt(i++);
 
-           /* v6 separator */
+           // v6 separator
            if (ch == ':') {
                curtok = i;
                if (!saw_xdigit) {
-                   /* no need to check separator position validity - regexp does that */
+                   // no need to check separator position validity - regexp does that
                    colonp = j;
                    continue;
                }
 
-               /* removed overrun check - the regexp checks for valid data */
+               // removed overrun check - the regexp checks for valid data
 
                dst[j++] = (byte) ((val >>> 8) & 0xff);
                dst[j++] = (byte) (val & 0xff);
@@ -104,26 +96,20 @@ final class Ipv6Utils {
                continue;
            }
 
-           /* frankenstein - v4 attached to v6, mixed notation */
+           // frankenstein - v4 attached to v6, mixed notation
            if (ch == '.' && ((j + INADDR4SZ) <= INADDR6SZ)) {
-
-               /* this has passed the regexp so it is fairly safe to parse it
-                * straight away. As v4 addresses do not suffer from the same
-                * deficiencies as the java v6 implementation we can invoke it
-                * straight away and be done with it
+               /*
+                * This has passed the regexp so it is fairly safe to parse it
+                * straight away. Use the Ipv4Utils for that.
                 */
-               Preconditions.checkArgument(j != (INADDR6SZ - INADDR4SZ - 1), "Invalid v4 in v6 mapping in %s", ipv6Address);
-               InetAddress _inet_form = InetAddresses.forString(address.substring(curtok, src_length));
-
-               Preconditions.checkArgument(_inet_form instanceof Inet4Address);
-               System.arraycopy(_inet_form.getAddress(), 0, dst, j, INADDR4SZ);
+               Ipv4Utils.fillIpv4Bytes(dst, j, addrStr, curtok, addrStrLen);
                j += INADDR4SZ;
-
                saw_xdigit = false;
                break;
            }
 
-           /* Business as usual - ipv6 address digit.
+           /*
+            * Business as usual - ipv6 address digit.
             * We can remove all checks from the original BSD code because
             * the regexp has already verified that we are not being fed
             * anything bigger than 0xffff between the separators.
@@ -134,23 +120,23 @@ final class Ipv6Utils {
        }
 
        if (saw_xdigit) {
-           Verify.verify(j + INT16SZ <= INADDR6SZ, "Overrun in parsing of '%s', should not occur", ipv6Address);
+           Verify.verify(j + INT16SZ <= INADDR6SZ, "Overrun in parsing of '%s', should not occur", addrStr);
            dst[j++] = (byte) ((val >> 8) & 0xff);
            dst[j++] = (byte) (val & 0xff);
        }
 
        if (colonp != -1) {
-           Verify.verify(j != INADDR6SZ, "Overrun in parsing of '%s', should not occur", ipv6Address);
+           Verify.verify(j != INADDR6SZ, "Overrun in parsing of '%s', should not occur", addrStr);
 
            final int n = j - colonp;
            for (i = 1; i <= n; i++) {
-               dst[INADDR6SZ - i] = dst[colonp + n - i];
-               dst[colonp + n - i] = 0;
+               dst[INADDR6SZ - i] = dst[j - i];
+               dst[j - i] = 0;
            }
-           j = INADDR6SZ;
+       } else {
+           Verify.verify(j == INADDR6SZ, "Overrun in parsing of '%s', should not occur", addrStr);
        }
 
-       Verify.verify(j == INADDR6SZ, "Overrun in parsing of '%s', should not occur", ipv6Address);
        return dst;
    }
 }