import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNull;
/**
- * IPv4 address parsing for ietf-inet-types ipv4-address. This is an internal implementation class, not meant to be
- * exposed in any shape or form to the outside world, as the code relies on the fact that the strings presented to it
- * have been previously validated to conform to the regular expressions defined in the YANG model.
+ * IPv4 address parsing for {@code ietf-inet-types} ipv4-address. This is an internal implementation class, not meant to
+ * be used directly in any shape or form to the outside world, as the code relies on the fact that the strings presented
+ * to it have been previously validated to conform to the regular expressions defined in the YANG model.
*/
-@Beta
public final class Ipv4Utils {
- static final int INET4_LENGTH = 4;
+ public static final int INET4_LENGTH = 4;
private Ipv4Utils() {
// Hidden on purpose
}
- static void fillIpv4Bytes(final byte @NonNull[] bytes, final int byteStart, final String str, final int strStart,
- final int strLimit) {
+ public static void fillIpv4Bytes(final byte @NonNull[] bytes, final int byteStart, final String str,
+ final int strStart, final int strLimit) {
int out = byteStart;
int val = 0;
for (int i = strStart; i < strLimit; ++i) {
return sb.toString();
}
- static void appendIpv4String(final StringBuilder sb, final byte @NonNull[] bytes) {
+ public static void appendIpv4String(final StringBuilder sb, final byte @NonNull[] bytes) {
checkArgument(bytes.length == INET4_LENGTH, "IPv4 address length is 4 bytes");
sb.append(Byte.toUnsignedInt(bytes[0]));
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Verify.verify;
-import com.google.common.annotations.Beta;
import java.util.Arrays;
import java.util.HexFormat;
import org.eclipse.jdt.annotation.NonNull;
/**
- * IPv6 address parsing for ietf-inet-types ipv6-address and ipv6-prefix. This is an internal implementation
- * class, not meant to be exposed in any shape or form to the outside world, as the code relies on the fact that
- * the strings presented to it have been previously validated to conform to the regular expressions defined in
- * the YANG model.
- */
-/*
- * v6 routines added by Anton Ivanov on 14.6.2015
- * revised by Robert Varga
+ * IPv6 address parsing for {@code ietf-inet-types} ipv6-address and ipv6-prefix. This is an internal implementation
+ * class, not meant to be used directly in any shape or form to the outside world, as the code relies on the fact that
+ * the strings presented to it have been previously validated to conform to the regular expressions defined in the YANG
+ * model.
*
- * BIG FAT WARNING!!!
- * Read all of the following before you touch any v6 code or decide to
- * optimize it by invoking a "simple" Guava call
+ * <p>
+ * IPv6 routines added by Anton Ivanov on 14.6.2015, revised by Robert Varga
*
- * Java IPv6 is fundamentally broken and Google libraries do not fix it.
- * 1. Java will allways implicitly rewrite v4 mapped into v6 as a v4 address
- * and there is absolutely no way to override this behaviour
- * 2. Guava libraries cannot parse non-canonical IPv6. They will throw an
- * exception. Even if they did, they re-use the same broken java code
- * underneath.
+ * <p>
+ * <b>BIG FAT WARNING!!!</b>
+ * Read all of the following before you touch any v6 code or decide to optimize it by invoking a "simple" Guava call.
*
+ * <p>
+ * Java IPv6 is fundamentally broken and Google libraries do not fix it.
+ * <ol>
+ * <li>Java will always implicitly rewrite v4 mapped into v6 as a v4 address and there is absolutely no way to
+ * override this behaviour</li>
+ * <li>Guava libraries cannot parse non-canonical IPv6. They will throw an exception. Even if they did, they re-use
+ * the same broken java code underneath</li>
+ * </ol>
* This is why we have to parse v6 by ourselves.
*
- * The following conversion code is based on inet_cidr_pton_ipv6 in NetBSD
+ * <p>
+ * The following conversion code is based on inet_cidr_pton_ipv6 in NetBSD.
*
- * The original BSD code is licensed under standard BSD license. While we
- * are not obliged to provide an attribution, credit where credit is due.
- * As far as why it is similar to Sun's sun.net.util please ask Sun why
- * their code has the same variable names, comments and code flow.
+ * <p>
+ * The original BSD code is licensed under standard BSD license. While we are not obliged to provide an attribution,
+ * credit where credit is due. As far as why it is similar to Sun's sun.net.util please ask Sun why their code has the
+ * same variable names, comments and code flow.
*/
-@Beta
public final class Ipv6Utils {
- static final int INET6_LENGTH = 16;
+ public static final int INET6_LENGTH = 16;
private Ipv6Utils() {
// Hidden on purpose
* @throws NullPointerException if ipv6address is null
*/
@SuppressWarnings("checkstyle:localVariableName")
- static void fillIpv6Bytes(final byte @NonNull[] bytes, final String str, final int strLimit) {
+ public static void fillIpv6Bytes(final byte @NonNull[] bytes, final String str, final int strLimit) {
// Leading :: requires some special handling.
int i = 0;
if (str.charAt(i) == ':') {
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.model.ietf.util;
-
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertThrows;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.net.InetAddresses;
-import java.net.Inet4Address;
-import java.net.Inet6Address;
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import org.junit.Test;
-
-public class AbstractIetfInetUtilTest {
- private static final IpUtil UTIL = new IpUtil();
-
- private static void assertV4Equals(final String literal, final String append) {
- final byte[] expected = InetAddresses.forString(literal).getAddress();
- final byte[] actual = UTIL.ipv4AddressBytes(new IpClass(literal + append));
- assertArrayEquals(expected, actual);
- }
-
- private static void assertV4Equals(final String literal) {
- assertV4Equals(literal, "");
- }
-
- @Test
- public void testIpToBytesAndBack() {
- assertV4Equals("1.2.3.4");
- assertV4Equals("12.23.34.45");
- assertV4Equals("255.254.253.252");
- assertV4Equals("128.16.0.127");
-
- assertV4Equals("1.2.3.4", "%5");
- assertV4Equals("12.23.34.45", "%5");
- assertV4Equals("255.254.253.252", "%5");
- assertV4Equals("128.16.0.127", "%5");
-
- assertEquals(new IpClass("1.2.3.4").getValue().toLowerCase(),
- UTIL.ipAddressFor(UTIL.ipv4AddressBytes(new IpClass("1.2.3.4"))).getValue().toLowerCase());
- assertNotEquals(new IpClass("2.3.4.5").getValue().toLowerCase(),
- UTIL.ipAddressFor(UTIL.ipv4AddressBytes(new IpClass("1.2.3.4"))).getValue().toLowerCase());
-
- assertEquals(new IpClass("FE80::2002:B3FF:FE1E:8329").getValue().toLowerCase(),
- UTIL.ipAddressFor(
- UTIL.ipv6AddressBytes(new IpClass("FE80::2002:B3FF:FE1E:8329"))).getValue().toLowerCase());
- assertNotEquals(new IpClass("FEFF::2002:B3FF:FE1E:8329").getValue().toLowerCase(),
- UTIL.ipAddressFor(
- UTIL.ipv6AddressBytes(new IpClass("FE80::2002:B3FF:FE1E:8329"))).getValue().toLowerCase());
-
- assertEquals(new IpClass("1.2.3.4").getValue().toLowerCase(),
- UTIL.ipAddressFor(UTIL.inetAddressFor(new IpClass("1.2.3.4"))).getValue().toLowerCase());
- assertNotEquals(new IpClass("2.3.4.5").getValue().toLowerCase(),
- UTIL.ipAddressFor(UTIL.inetAddressFor(new IpClass("1.2.3.4"))).getValue().toLowerCase());
-
- assertEquals(new IpClass("FE80::2002:B3FF:FE1E:8329").getValue().toLowerCase(),
- UTIL.ipAddressFor(
- UTIL.inetAddressFor(new IpClass("FE80::2002:B3FF:FE1E:8329"))).getValue().toLowerCase());
- assertNotEquals(new IpClass("FEFF::2002:B3FF:FE1E:8329").getValue().toLowerCase(),
- UTIL.ipAddressFor(
- UTIL.inetAddressFor(new IpClass("FE80::2002:B3FF:FE1E:8329"))).getValue().toLowerCase());
- }
-
- @Test
- public void illegalArrayLengthForAddressTest() {
- final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
- () -> UTIL.ipAddressFor(new byte[] { 0, 0, 0 }));
- assertEquals("Invalid array length 3", ex.getMessage());
- }
-
- @Test
- public void unhandledAddressTest() {
- final InetAddress adr = mock(InetAddress.class);
- doReturn("testAddress").when(adr).toString();
- final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> UTIL.ipAddressFor(adr));
- assertEquals("Unhandled address testAddress", ex.getMessage());
- }
-
- @Test
- public void illegalArrayLengthforPrefixTest() {
- final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
- () -> UTIL.ipPrefixFor(new byte[] { 0, 0, 0 }, 0));
- assertEquals("Invalid array length 3", ex.getMessage());
- }
-
- @Test
- public void illegalAddressforPrefixTest() {
- final InetAddress adr = mock(InetAddress.class);
- doReturn("testAddress").when(adr).toString();
-
- final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
- () -> UTIL.ipPrefixFor(adr, 0));
- assertEquals("Unhandled address testAddress", ex.getMessage());
- }
-
- @Test
- public void ipv4Tests() {
- assertEquals("1.2.3.4", UTIL.ipv4AddressFrom(new IpClass("1.2.3.4/16")).getValue());
- final IpClass ipClass = new IpClass("1.2.3.4");
- assertEquals("1.2.3.4/32", UTIL.ipv4PrefixFor(UTIL.ipv4AddressBytes(ipClass)).getValue());
- assertEquals("1.2.3.4/32", UTIL.ipv4PrefixFor(UTIL.inetAddressFor(ipClass)).getValue());
- assertEquals("1.2.3.4/32", UTIL.ipv4PrefixFor(ipClass).getValue());
- assertEquals("1.2.3.4/16", UTIL.ipv4PrefixFor(ipClass, 16).getValue());
-
- assertEquals("0.0.0.0/0", UTIL.ipv4PrefixForShort(UTIL.ipv4AddressBytes(ipClass), 0).getValue());
- assertEquals("1.2.3.4/32", UTIL.ipv4PrefixForShort(UTIL.ipv4AddressBytes(ipClass), 32).getValue());
- assertEquals("0.0.0.0/0", UTIL.ipv4PrefixForShort(UTIL.ipv4AddressBytes(ipClass), 0, 0).getValue());
- assertEquals("1.2.3.4/32", UTIL.ipv4PrefixForShort(UTIL.ipv4AddressBytes(ipClass), 0, 32).getValue());
- assertEquals("2.3.4.5/32", UTIL.ipv4PrefixForShort(new byte[] { 1, 2, 3, 4, 5 }, 1, 32).getValue());
- assertEquals("1.0.0.0/1", UTIL.ipv4PrefixForShort(new byte[] { 1, 2, 3, 4, 5 }, 0, 1).getValue());
-
- assertEquals("1.2.3.4", UTIL.splitIpv4Prefix(new IpClass("1.2.3.4/16")).getKey().getValue());
- assertEquals((Integer) 16, UTIL.splitIpv4Prefix(new IpClass("1.2.3.4/16")).getValue());
- assertArrayEquals(new byte[] { 1,2,3,4,16 }, UTIL.ipv4PrefixToBytes(new IpClass("1.2.3.4/16")));
- }
-
- @Test
- public void ipv6Tests() {
- assertEquals("::0", UTIL.ipv6AddressFrom(new IpClass("::0/128")).getValue());
- final IpClass ipClass = new IpClass("::0");
- assertEquals("::/128", UTIL.ipv6PrefixFor(UTIL.ipv6AddressBytes(ipClass)).getValue());
- assertEquals("::/128", UTIL.ipv6PrefixFor(UTIL.inetAddressFor(ipClass)).getValue());
- assertEquals("::0/128", UTIL.ipv6PrefixFor(ipClass).getValue());
- assertEquals("::0/16", UTIL.ipv6PrefixFor(ipClass, 16).getValue());
-
- assertEquals("::0/0", UTIL.ipv6PrefixForShort(UTIL.ipv6AddressBytes(ipClass), 0).getValue());
- assertEquals("::/64", UTIL.ipv6PrefixForShort(UTIL.ipv6AddressBytes(ipClass), 64).getValue());
- assertEquals("::0/0", UTIL.ipv6PrefixForShort(UTIL.ipv6AddressBytes(ipClass), 0, 0).getValue());
- assertEquals("::/32", UTIL.ipv6PrefixForShort(UTIL.ipv6AddressBytes(ipClass), 0, 32).getValue());
-
- assertEquals("::", UTIL.splitIpv6Prefix(new IpClass("::/32")).getKey().getValue());
- assertEquals((Integer) 32, UTIL.splitIpv6Prefix(new IpClass("::/32")).getValue());
- assertArrayEquals(new byte[] { 0, 10, 0, 0, 0, 0, 0, 0, 0, 11, 0, 12, 0, 13, 0, 14, 64 },
- UTIL.ipv6PrefixToBytes(new IpClass("A::B:C:D:E/64")));
-
- // verify that an IPv4-mapped IPv6 address gets parsed as an IPv6 address
- assertEquals("::ffff:ab0:eb", UTIL.ipv6AddressFor(
- new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (byte) 0xff, (byte) 0xff, 0x0a, (byte) 0xb0, 0, (byte) 0xeb})
- .getValue());
- }
-
- @Test
- public void prefixTest() {
- assertEquals("0.0.0.0/16", UTIL.ipPrefixFor(UTIL.inetAddressFor(new IpClass("0.0.0.0")), 16).getValue());
- assertEquals("::/64", UTIL.ipPrefixFor(UTIL.inetAddressFor(new IpClass("::")), 64).getValue());
-
- assertEquals("0.0.0.0/16", UTIL.ipPrefixFor(new byte[] { 0, 0, 0, 0 }, 16).getValue());
- assertEquals("::/64",
- UTIL.ipPrefixFor(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 64).getValue());
- }
-
- @Test
- public void inetAddressTest() {
- assertThat(UTIL.inetAddressFor(new IpClass("1.2.3.4")), instanceOf(Inet4Address.class));
- assertThat(UTIL.inetAddressFor(new IpClass("FE80::2002:B3FF:FE1E:8329")), instanceOf(Inet6Address.class));
- }
-
- @Test
- public void inet4AddressForWithExceptionTest() {
- final IpClass ipClass = mock(IpClass.class);
- doReturn("testClass").when(ipClass).toString();
- doAnswer(inv -> {
- throw new UnknownHostException();
- }).when(ipClass).getValue();
-
- final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
- () -> UTIL.inet4AddressFor(ipClass));
- assertEquals("Invalid address testClass", ex.getMessage());
- }
-
- @Test
- public void inet6AddressForWithExceptionTest() {
- final IpClass ipClass = mock(IpClass.class);
- doReturn("testClass").when(ipClass).toString();
- doAnswer(inv -> {
- throw new UnknownHostException();
- }).when(ipClass).getValue();
-
- final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
- () -> UTIL.inet6AddressFor(ipClass));
- assertEquals("Invalid address testClass", ex.getMessage());
- }
-
- @Test
- public void testIpv4AddressForBits() {
- assertEquals("1.2.3.4", UTIL.ipv4AddressFor(0x01020304).getValue());
- assertEquals("255.255.255.255", UTIL.ipv4AddressFor(0xFFFFFFFF).getValue());
- }
-
- @Test
- public void testIpv4AddressBits() {
- assertEquals(0x01020304, UTIL.ipv4AddressBits(new IpClass("1.2.3.4")));
- assertEquals(0xFFFFFFFF, UTIL.ipv4AddressBits(new IpClass("255.255.255.255")));
- }
-
- @Test
- public void testIpv4AddressNoZoneBits() {
- assertEquals(0x01020304, UTIL.ipv4AddressNoZoneBits(new IpClass("1.2.3.4")));
- assertEquals(0xFFFFFFFF, UTIL.ipv4AddressNoZoneBits(new IpClass("255.255.255.255")));
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.model.ietf.util;
-
-import static java.util.Objects.requireNonNull;
-
-@SuppressWarnings("checkstyle:memberName")
-public class IpClass {
- private final String _value;
-
- public IpClass(final String value) {
- this._value = requireNonNull(value);
- }
-
- public IpClass(final IpClass template) {
- this._value = template._value;
- }
-
- String getValue() {
- return this._value;
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.model.ietf.util;
-
-import java.util.regex.Pattern;
-import org.checkerframework.checker.regex.qual.Regex;
-
-final class IpUtil extends AbstractIetfInetUtil<IpClass, IpClass, IpClass, IpClass, IpClass, IpClass, IpClass, IpClass,
- IpClass> {
-
- @Regex
- private static final String IP_V4_REGEX = "^\\d+\\.\\d+\\.\\d+\\.\\d+$";
- private static final Pattern IP_V4_PATTERN = Pattern.compile(IP_V4_REGEX);
-
- IpUtil() {
- super(IpClass.class, IpClass.class, IpClass.class, IpClass.class);
- }
-
- @Override
- protected IpClass ipv4Address(final IpClass addr) {
- return addr;
- }
-
-
- @Override
- protected IpClass ipv4AddressNoZone(final IpClass addr) {
- return addr;
- }
-
- @Override
- protected IpClass ipv6Address(final IpClass addr) {
- return addr;
- }
-
- @Override
- protected IpClass ipv6AddressNoZone(final IpClass addr) {
- return addr;
- }
-
- @Override
- protected IpClass ipv4Prefix(final IpClass addr) {
- return addr;
- }
-
- @Override
- protected IpClass ipv6Prefix(final IpClass addr) {
- return addr;
- }
-
- @Override
- protected String ipv4AddressString(final IpClass addr) {
- return addr.getValue();
- }
-
- @Override
- protected String ipv6AddressString(final IpClass addr) {
- return addr.getValue();
- }
-
- @Override
- protected String ipv4PrefixString(final IpClass prefix) {
- return prefix.getValue();
- }
-
- @Override
- protected String ipv6PrefixString(final IpClass prefix) {
- return prefix.getValue();
- }
-
- @Override
- protected IpClass maybeIpv4Address(final IpClass addr) {
- return IP_V4_PATTERN.matcher(addr.getValue()).matches() ? addr : null;
- }
-
- @Override
- protected IpClass maybeIpv4AddressNoZone(final IpClass addr) {
- return maybeIpv4Address(addr);
- }
-
- @Override
- protected IpClass maybeIpv6Address(final IpClass addr) {
- return addr.getValue().indexOf(':') != -1 ? addr : null;
- }
-
- @Override
- protected IpClass maybeIpv6AddressNoZone(final IpClass addr) {
- return maybeIpv6Address(addr);
- }
-}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.mdsal.model.ietf.util;
+package org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715;
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.spec.reflect.StringValueObjectFactory;
+import org.opendaylight.mdsal.model.ietf.util.Ipv4Utils;
+import org.opendaylight.mdsal.model.ietf.util.Ipv6Utils;
/**
* A set of utility methods to efficiently instantiate various ietf-inet-types DTOs.
*/
@Beta
@SuppressWarnings("checkstyle:classTypeParameterName")
-public abstract class AbstractIetfInetUtil<A4, A4NZ extends A4, P4, A6, A6NZ extends A6, P6, A, ANZ, P> {
- private final StringValueObjectFactory<A4NZ> address4NoZoneFactory;
- private final StringValueObjectFactory<P4> prefix4Factory;
- private final StringValueObjectFactory<A6NZ> address6NoZoneFactory;
- private final StringValueObjectFactory<P6> prefix6Factory;
- private final Class<A4NZ> addr4nzClass;
- private final Class<A6NZ> addr6nzClass;
+public abstract class AbstractIetfInetUtil {
+ private final StringValueObjectFactory<Ipv4AddressNoZone> address4NoZoneFactory =
+ StringValueObjectFactory.create(Ipv4AddressNoZone.class, "0.0.0.0");
+ private final StringValueObjectFactory<Ipv4Prefix> prefix4Factory =
+ StringValueObjectFactory.create(Ipv4Prefix.class, "0.0.0.0/0");
+ private final StringValueObjectFactory<Ipv6AddressNoZone> address6NoZoneFactory =
+ StringValueObjectFactory.create(Ipv6AddressNoZone.class, "::0");
+ private final StringValueObjectFactory<Ipv6Prefix> prefix6Factory =
+ StringValueObjectFactory.create(Ipv6Prefix.class, "::0/0");
- protected AbstractIetfInetUtil(final Class<A4NZ> addr4nzClass, final Class<P4> prefix4Class,
- final Class<A6NZ> addr6nzClass, final Class<P6> prefix6Class) {
- this.addr4nzClass = requireNonNull(addr4nzClass);
- this.addr6nzClass = requireNonNull(addr6nzClass);
- this.address4NoZoneFactory = StringValueObjectFactory.create(addr4nzClass, "0.0.0.0");
- this.prefix4Factory = StringValueObjectFactory.create(prefix4Class, "0.0.0.0/0");
- this.address6NoZoneFactory = StringValueObjectFactory.create(addr6nzClass, "::0");
- this.prefix6Factory = StringValueObjectFactory.create(prefix6Class, "::0/0");
- }
-
- protected abstract @NonNull A ipv4Address(@NonNull A4NZ addr);
+ protected abstract @NonNull IpAddress ipv4Address(@NonNull Ipv4AddressNoZone addr);
- protected abstract @NonNull ANZ ipv4AddressNoZone(@NonNull A4NZ addr);
+ protected abstract @NonNull IpAddressNoZone ipv4AddressNoZone(@NonNull Ipv4AddressNoZone addr);
- protected abstract @NonNull A ipv6Address(@NonNull A6NZ addr);
+ protected abstract @NonNull IpAddress ipv6Address(@NonNull Ipv6AddressNoZone addr);
- protected abstract @NonNull ANZ ipv6AddressNoZone(@NonNull A6NZ addr);
+ protected abstract @NonNull IpAddressNoZone ipv6AddressNoZone(@NonNull Ipv6AddressNoZone addr);
- protected abstract @Nullable A4 maybeIpv4Address(@NonNull A addr);
+ protected abstract @Nullable Ipv4Address maybeIpv4Address(@NonNull IpAddress addr);
- protected abstract @Nullable A4NZ maybeIpv4AddressNoZone(@NonNull ANZ addr);
+ protected abstract @Nullable Ipv4AddressNoZone maybeIpv4AddressNoZone(@NonNull IpAddressNoZone addr);
- protected abstract @Nullable A6 maybeIpv6Address(@NonNull A addr);
+ protected abstract @Nullable Ipv6Address maybeIpv6Address(@NonNull IpAddress addr);
- protected abstract @Nullable A6NZ maybeIpv6AddressNoZone(@NonNull ANZ addr);
+ protected abstract @Nullable Ipv6AddressNoZone maybeIpv6AddressNoZone(@NonNull IpAddressNoZone addr);
- protected abstract @NonNull P ipv4Prefix(@NonNull P4 addr);
+ protected abstract @NonNull IpPrefix ipv4Prefix(@NonNull Ipv4Prefix addr);
- protected abstract @NonNull P ipv6Prefix(@NonNull P6 addr);
+ protected abstract @NonNull IpPrefix ipv6Prefix(@NonNull Ipv6Prefix addr);
- protected abstract @NonNull String ipv4AddressString(@NonNull A4 addr);
+ protected abstract @NonNull String ipv4AddressString(@NonNull Ipv4Address addr);
- protected abstract @NonNull String ipv6AddressString(@NonNull A6 addr);
+ protected abstract @NonNull String ipv6AddressString(@NonNull Ipv6Address addr);
- protected abstract @NonNull String ipv4PrefixString(@NonNull P4 prefix);
+ protected abstract @NonNull String ipv4PrefixString(@NonNull Ipv4Prefix prefix);
- protected abstract @NonNull String ipv6PrefixString(@NonNull P6 prefix);
+ protected abstract @NonNull String ipv6PrefixString(@NonNull Ipv6Prefix prefix);
/**
* Create an IpAddress by interpreting input bytes as an IPv4 or IPv6 address, based on array length.
* @throws IllegalArgumentException if bytes has length different from 4 or 6
* @throws NullPointerException if bytes is null
*/
- public final @NonNull A ipAddressFor(final byte @NonNull[] bytes) {
+ public final @NonNull IpAddress ipAddressFor(final byte @NonNull[] bytes) {
return switch (bytes.length) {
case Ipv4Utils.INET4_LENGTH -> ipv4Address(ipv4AddressFor(bytes));
case Ipv6Utils.INET6_LENGTH -> ipv6Address(ipv6AddressFor(bytes));
};
}
- public final @NonNull A ipAddressFor(final @NonNull InetAddress addr) {
+ public final @NonNull IpAddress ipAddressFor(final @NonNull InetAddress addr) {
requireAddress(addr);
if (addr instanceof Inet4Address) {
return ipv4Address(ipv4AddressFor(addr));
* @throws IllegalArgumentException if bytes has length different from 4 or 6
* @throws NullPointerException if bytes is null
*/
- public final @NonNull ANZ ipAddressNoZoneFor(final byte @NonNull[] bytes) {
+ public final @NonNull IpAddressNoZone ipAddressNoZoneFor(final byte @NonNull[] bytes) {
return switch (bytes.length) {
case Ipv4Utils.INET4_LENGTH -> ipv4AddressNoZone(ipv4AddressFor(bytes));
case Ipv6Utils.INET6_LENGTH -> ipv6AddressNoZone(ipv6AddressFor(bytes));
};
}
- public final @NonNull ANZ ipAddressNoZoneFor(final @NonNull InetAddress addr) {
+ public final @NonNull IpAddressNoZone ipAddressNoZoneFor(final @NonNull InetAddress addr) {
requireAddress(addr);
if (addr instanceof Inet4Address) {
return ipv4AddressNoZone(ipv4AddressFor(addr));
* in range 0-32 or 0-128 respectively
* @throws NullPointerException if bytes is null
*/
- public final @NonNull P ipPrefixFor(final byte @NonNull[] bytes, final int mask) {
+ public final @NonNull IpPrefix ipPrefixFor(final byte @NonNull[] bytes, final int mask) {
return switch (bytes.length) {
case Ipv4Utils.INET4_LENGTH -> ipv4Prefix(ipv4PrefixFor(bytes, mask));
case Ipv6Utils.INET6_LENGTH -> ipv6Prefix(ipv6PrefixFor(bytes, mask));
};
}
- public final @NonNull P ipPrefixFor(final @NonNull InetAddress addr, final int mask) {
+ public final @NonNull IpPrefix ipPrefixFor(final @NonNull InetAddress addr, final int mask) {
requireAddress(addr);
if (addr instanceof Inet4Address) {
return ipv4Prefix(ipv4PrefixFor(addr, mask));
}
}
- public final @NonNull P ipPrefixFor(final @NonNull A addr) {
- final A4 v4 = maybeIpv4Address(addr);
+ public final @NonNull IpPrefix ipPrefixFor(final @NonNull IpAddress addr) {
+ final var v4 = maybeIpv4Address(addr);
return v4 != null ? ipv4Prefix(ipv4PrefixFor(v4)) : ipv6Prefix(ipv6PrefixFor(coerceIpv6Address(addr)));
}
- public final @NonNull P ipPrefixForNoZone(final @NonNull ANZ addr) {
- final A4NZ v4 = maybeIpv4AddressNoZone(addr);
+ public final @NonNull IpPrefix ipPrefixForNoZone(final @NonNull IpAddressNoZone addr) {
+ final var v4 = maybeIpv4AddressNoZone(addr);
return v4 != null ? ipv4Prefix(ipv4PrefixFor(inet4AddressForNoZone(v4)))
: ipv6Prefix(ipv6PrefixFor(coerceIpv6AddressNoZone(addr)));
}
- public final @NonNull InetAddress inetAddressFor(final @NonNull A addr) {
- final A4 v4 = maybeIpv4Address(addr);
+ public final @NonNull InetAddress inetAddressFor(final @NonNull IpAddress addr) {
+ final var v4 = maybeIpv4Address(addr);
return v4 != null ? inet4AddressFor(v4) : inet6AddressFor(coerceIpv6Address(addr));
}
- public final @NonNull InetAddress inetAddressForNoZone(final @NonNull ANZ addr) {
- final A4NZ v4 = maybeIpv4AddressNoZone(addr);
+ public final @NonNull InetAddress inetAddressForNoZone(final @NonNull IpAddressNoZone addr) {
+ final var v4 = maybeIpv4AddressNoZone(addr);
return v4 != null ? inet4AddressForNoZone(v4) : inet6AddressForNoZone(coerceIpv6AddressNoZone(addr));
}
- public final @NonNull Inet4Address inet4AddressFor(final @NonNull A4 addr) {
+ public final @NonNull Inet4Address inet4AddressFor(final @NonNull Ipv4Address addr) {
try {
return (Inet4Address) InetAddress.getByAddress(ipv4AddressBytes(addr));
} catch (UnknownHostException e) {
}
}
- public final @NonNull Inet4Address inet4AddressForNoZone(final @NonNull A4NZ addr) {
+ public final @NonNull Inet4Address inet4AddressForNoZone(final @NonNull Ipv4AddressNoZone addr) {
try {
return (Inet4Address) InetAddress.getByAddress(ipv4AddressNoZoneBytes(addr));
} catch (UnknownHostException e) {
}
}
- public final @NonNull Inet6Address inet6AddressFor(final @NonNull A6 addr) {
+ public final @NonNull Inet6Address inet6AddressFor(final @NonNull Ipv6Address addr) {
try {
return (Inet6Address) InetAddress.getByAddress(ipv6AddressBytes(addr));
} catch (UnknownHostException e) {
}
}
- public final @NonNull Inet6Address inet6AddressForNoZone(final @NonNull A6NZ addr) {
+ public final @NonNull Inet6Address inet6AddressForNoZone(final @NonNull Ipv6AddressNoZone addr) {
try {
return (Inet6Address) InetAddress.getByAddress(ipv6AddressNoZoneBytes(addr));
} catch (UnknownHostException e) {
* @throws IllegalArgumentException if bytes has length different from 4
* @throws NullPointerException if bytes is null
*/
- public final @NonNull A4NZ ipv4AddressFor(final byte @NonNull[] bytes) {
+ public final @NonNull Ipv4AddressNoZone ipv4AddressFor(final byte @NonNull[] bytes) {
return address4NoZoneFactory.newInstance(Ipv4Utils.addressString(bytes));
}
* @throws IllegalArgumentException if addr is not an {@link Inet4Address}
* @throws NullPointerException if addr is null
*/
- public final @NonNull A4NZ ipv4AddressFor(final @NonNull InetAddress addr) {
+ public final @NonNull Ipv4AddressNoZone ipv4AddressFor(final @NonNull InetAddress addr) {
return address4NoZoneFactory.newInstance(addressStringV4(addr));
}
* @param bits 32 bits, big endian
* @return An Ipv4AddressNoZone object
*/
- public final @NonNull A4NZ ipv4AddressFor(final int bits) {
+ public final @NonNull Ipv4AddressNoZone ipv4AddressFor(final int bits) {
return address4NoZoneFactory.newInstance(Ipv4Utils.addressString(bits));
}
* @return An Ipv4AddressNoZone object
* @throws NullPointerException if addr is null
*/
- public final @NonNull A4NZ ipv4AddressNoZoneFor(final @NonNull A4 addr) {
+ public final @NonNull Ipv4AddressNoZone ipv4AddressNoZoneFor(final @NonNull Ipv4Address addr) {
requireAddress(addr);
- return addr4nzClass.isInstance(addr) ? addr4nzClass.cast(addr)
- : address4NoZoneFactory.newInstance(stripZone(ipv4AddressString(addr)));
+ return addr instanceof Ipv4AddressNoZone noZone ? noZone
+ : address4NoZoneFactory.newInstance(stripZone(ipv4AddressString(addr)));
}
- public final @NonNull A4NZ ipv4AddressFrom(final @NonNull P4 prefix) {
+ public final @NonNull Ipv4AddressNoZone ipv4AddressFrom(final @NonNull Ipv4Prefix prefix) {
return prefixToAddress(address4NoZoneFactory, ipv4PrefixString(prefix));
}
- public final byte @NonNull[] ipv4AddressBytes(final @NonNull A4 addr) {
+ public final byte @NonNull[] ipv4AddressBytes(final @NonNull Ipv4Address addr) {
/*
* This implementation relies heavily on the input string having been validated to comply with
* the Ipv4Address pattern, which may include a zone index.
return Ipv4Utils.addressBytes(str, percent == -1 ? str.length() : percent);
}
- public final int ipv4AddressBits(final @NonNull A4 addr) {
+ public final int ipv4AddressBits(final @NonNull Ipv4Address addr) {
final String str = ipv4AddressString(addr);
final int percent = str.indexOf('%');
return Ipv4Utils.addressBits(str, percent == -1 ? str.length() : percent);
}
- public final byte @NonNull[] ipv4AddressNoZoneBytes(final @NonNull A4NZ addr) {
+ public final byte @NonNull[] ipv4AddressNoZoneBytes(final @NonNull Ipv4AddressNoZone addr) {
/*
* This implementation relies heavily on the input string having been validated to comply with
* the Ipv4AddressNoZone pattern, which must not include a zone index.
return Ipv4Utils.addressBytes(str, str.length());
}
- public final int ipv4AddressNoZoneBits(final @NonNull A4NZ addr) {
+ public final int ipv4AddressNoZoneBits(final @NonNull Ipv4AddressNoZone addr) {
final String str = ipv4AddressString(addr);
return Ipv4Utils.addressBits(str, str.length());
}
* @throws IllegalArgumentException if bytes has length different from 4
* @throws NullPointerException if bytes is null
*/
- public final @NonNull P4 ipv4PrefixFor(final byte @NonNull[] bytes) {
+ public final @NonNull Ipv4Prefix ipv4PrefixFor(final byte @NonNull[] bytes) {
return prefix4Factory.newInstance(prefixStringV4(bytes));
}
* @throws IllegalArgumentException if bytes has length different from 4 or if mask is not in range 0-32
* @throws NullPointerException if bytes is null
*/
- public final @NonNull P4 ipv4PrefixFor(final byte @NonNull[] address, final int mask) {
+ public final @NonNull Ipv4Prefix ipv4PrefixFor(final byte @NonNull[] address, final int mask) {
return prefix4Factory.newInstance(prefixStringV4(address, mask));
}
* @throws IllegalArgumentException if addr is not an Inet4Address
* @throws NullPointerException if addr is null
*/
- public final @NonNull P4 ipv4PrefixFor(final @NonNull InetAddress addr) {
+ public final @NonNull Ipv4Prefix ipv4PrefixFor(final @NonNull InetAddress addr) {
return prefix4Factory.newInstance(addressStringV4(addr) + "/32");
}
* @throws IllegalArgumentException if addr is not an Inet4Address or if mask is not in range 0-32
* @throws NullPointerException if addr is null
*/
- public final @NonNull P4 ipv4PrefixFor(final @NonNull InetAddress addr, final int mask) {
+ public final @NonNull Ipv4Prefix ipv4PrefixFor(final @NonNull InetAddress addr, final int mask) {
return newIpv4Prefix(addressStringV4(addr), mask);
}
- public final @NonNull P4 ipv4PrefixFor(final @NonNull A4 addr) {
+ public final @NonNull Ipv4Prefix ipv4PrefixFor(final @NonNull Ipv4Address addr) {
return prefix4Factory.newInstance(stripZone(ipv4AddressString(requireAddress(addr))) + "/32");
}
- public final @NonNull P4 ipv4PrefixFor(final @NonNull A4 addr, final int mask) {
+ public final @NonNull Ipv4Prefix ipv4PrefixFor(final @NonNull Ipv4Address addr, final int mask) {
return newIpv4Prefix(stripZone(ipv4AddressString(requireAddress(addr))), mask);
}
- public final @NonNull P4 ipv4PrefixForNoZone(final @NonNull A4NZ addr) {
+ public final @NonNull Ipv4Prefix ipv4PrefixForNoZone(final @NonNull Ipv4AddressNoZone addr) {
return prefix4Factory.newInstance(ipv4AddressString(requireAddress(addr)) + "/32");
}
- public final @NonNull P4 ipv4PrefixForNoZone(final @NonNull A4NZ addr, final int mask) {
+ public final @NonNull Ipv4Prefix ipv4PrefixForNoZone(final @NonNull Ipv4AddressNoZone addr, final int mask) {
return newIpv4Prefix(ipv4AddressString(requireAddress(addr)), mask);
}
- public final @NonNull P4 ipv4PrefixForShort(final byte @NonNull[] address, final int mask) {
+ public final @NonNull Ipv4Prefix ipv4PrefixForShort(final byte @NonNull[] address, final int mask) {
if (mask == 0) {
// Easy case, reuse the template
return prefix4Factory.getTemplate();
return v4PrefixForShort(address, 0, mask / Byte.SIZE + (mask % Byte.SIZE == 0 ? 0 : 1), mask);
}
- public final @NonNull P4 ipv4PrefixForShort(final byte @NonNull[] array, final int startOffset, final int mask) {
+ public final @NonNull Ipv4Prefix ipv4PrefixForShort(final byte @NonNull[] array, final int startOffset,
+ final int mask) {
if (mask == 0) {
// Easy case, reuse the template
return prefix4Factory.getTemplate();
return percent == -1 ? str : str.substring(0, percent);
}
- private @NonNull P4 newIpv4Prefix(final String addr, final int mask) {
+ private @NonNull Ipv4Prefix newIpv4Prefix(final String addr, final int mask) {
checkArgument(mask >= 0 && mask <= 32, "Invalid mask %s", mask);
return prefix4Factory.newInstance(addr + '/' + mask);
}
- public final @NonNull Entry<A4NZ, Integer> splitIpv4Prefix(final @NonNull P4 prefix) {
+ public final @NonNull Entry<Ipv4AddressNoZone, Integer> splitIpv4Prefix(final @NonNull Ipv4Prefix prefix) {
return splitPrefix(address4NoZoneFactory, ipv4PrefixString(prefix));
}
- public final byte @NonNull[] ipv4PrefixToBytes(final @NonNull P4 prefix) {
+ public final byte @NonNull[] ipv4PrefixToBytes(final @NonNull Ipv4Prefix prefix) {
final String str = ipv4PrefixString(prefix);
final int slash = str.lastIndexOf('/');
* @throws IllegalArgumentException if bytes has length different from 16
* @throws NullPointerException if bytes is null
*/
- public final @NonNull A6NZ ipv6AddressFor(final byte @NonNull[] bytes) {
+ public final @NonNull Ipv6AddressNoZone ipv6AddressFor(final byte @NonNull[] bytes) {
return address6NoZoneFactory.newInstance(addressStringV6(bytes));
}
* @throws IllegalArgumentException if addr is not an {@link Inet6Address}
* @throws NullPointerException if addr is null
*/
- public final @NonNull A6NZ ipv6AddressFor(final @NonNull InetAddress addr) {
+ public final @NonNull Ipv6AddressNoZone ipv6AddressFor(final @NonNull InetAddress addr) {
return address6NoZoneFactory.newInstance(addressStringV6(addr));
}
* @return An Ipv6AddressNoZone object
* @throws NullPointerException if addr is null
*/
- public final @NonNull A6NZ ipv6AddressNoZoneFor(final @NonNull A6 addr) {
+ public final @NonNull Ipv6AddressNoZone ipv6AddressNoZoneFor(final @NonNull Ipv6Address addr) {
requireAddress(addr);
- return addr6nzClass.isInstance(addr) ? addr6nzClass.cast(addr)
+ return addr instanceof Ipv6AddressNoZone noZone ? noZone
: address6NoZoneFactory.newInstance(stripZone(ipv6AddressString(addr)));
}
- public final @NonNull A6NZ ipv6AddressFrom(final @NonNull P6 prefix) {
+ public final @NonNull Ipv6AddressNoZone ipv6AddressFrom(final @NonNull Ipv6Prefix prefix) {
return prefixToAddress(address6NoZoneFactory, ipv6PrefixString(prefix));
}
- public final byte @NonNull[] ipv6AddressBytes(final @NonNull A6 addr) {
+ public final byte @NonNull[] ipv6AddressBytes(final @NonNull Ipv6Address addr) {
final String str = ipv6AddressString(addr);
final int percent = str.indexOf('%');
return ipv6StringBytes(str, percent == -1 ? str.length() : percent);
}
- public final byte @NonNull[] ipv6AddressNoZoneBytes(final @NonNull A6NZ addr) {
+ public final byte @NonNull[] ipv6AddressNoZoneBytes(final @NonNull Ipv6Address addr) {
final String str = ipv6AddressString(addr);
return ipv6StringBytes(str, str.length());
}
* @throws IllegalArgumentException if bytes has length different from 16
* @throws NullPointerException if bytes is null
*/
- public final @NonNull P6 ipv6PrefixFor(final byte @NonNull[] bytes) {
+ public final @NonNull Ipv6Prefix ipv6PrefixFor(final byte @NonNull[] bytes) {
return prefix6Factory.newInstance(addressStringV6(bytes) + "/128");
}
* @throws IllegalArgumentException if bytes has length different from 16 or if mask is not in range 0-128
* @throws NullPointerException if bytes is null
*/
- public final @NonNull P6 ipv6PrefixFor(final byte @NonNull[] address, final int mask) {
+ public final @NonNull Ipv6Prefix ipv6PrefixFor(final byte @NonNull[] address, final int mask) {
checkArgument(mask >= 0 && mask <= 128, "Invalid mask %s", mask);
return prefix6Factory.newInstance(addressStringV6(address) + '/' + mask);
}
* @throws IllegalArgumentException if addr is not an Inet6Address
* @throws NullPointerException if addr is null
*/
- public final @NonNull P6 ipv6PrefixFor(final @NonNull InetAddress addr) {
+ public final @NonNull Ipv6Prefix ipv6PrefixFor(final @NonNull InetAddress addr) {
return prefix6Factory.newInstance(addressStringV6(addr) + "/128");
}
* @throws IllegalArgumentException if addr is not an Inet6Address or if mask is not in range 0-128
* @throws NullPointerException if addr is null
*/
- public final @NonNull P6 ipv6PrefixFor(final @NonNull InetAddress addr, final int mask) {
+ public final @NonNull Ipv6Prefix ipv6PrefixFor(final @NonNull InetAddress addr, final int mask) {
checkArgument(mask >= 0 && mask <= 128, "Invalid mask %s", mask);
return prefix6Factory.newInstance(addressStringV6(addr) + '/' + mask);
}
- public final @NonNull P6 ipv6PrefixFor(final @NonNull A6 addr) {
+ public final @NonNull Ipv6Prefix ipv6PrefixFor(final @NonNull Ipv6Address addr) {
return prefix6Factory.newInstance(stripZone(ipv6AddressString(requireAddress(addr))) + "/128");
}
- public final @NonNull P6 ipv6PrefixFor(final @NonNull A6 addr, final int mask) {
+ public final @NonNull Ipv6Prefix ipv6PrefixFor(final @NonNull Ipv6Address addr, final int mask) {
return newIpv6Prefix(stripZone(ipv6AddressString(requireAddress(addr))), mask);
}
- public final @NonNull P6 ipv6PrefixForNoZone(final @NonNull A6NZ addr) {
+ public final @NonNull Ipv6Prefix ipv6PrefixForNoZone(final @NonNull Ipv6AddressNoZone addr) {
return prefix6Factory.newInstance(ipv6AddressString(requireAddress(addr)) + "/128");
}
- public final @NonNull P6 ipv6PrefixForNoZone(final @NonNull A6NZ addr, final int mask) {
+ public final @NonNull Ipv6Prefix ipv6PrefixForNoZone(final @NonNull Ipv6AddressNoZone addr, final int mask) {
return newIpv6Prefix(ipv6AddressString(requireAddress(addr)), mask);
}
- public final @NonNull P6 ipv6PrefixForShort(final byte @NonNull[] address, final int mask) {
+ public final @NonNull Ipv6Prefix ipv6PrefixForShort(final byte @NonNull[] address, final int mask) {
return ipv6PrefixForShort(address, 0, mask);
}
- public final @NonNull P6 ipv6PrefixForShort(final byte @NonNull[] array, final int startOffset, final int mask) {
+ public final @NonNull Ipv6Prefix ipv6PrefixForShort(final byte @NonNull[] array, final int startOffset,
+ final int mask) {
if (mask == 0) {
// Easy case, reuse the template
return prefix6Factory.getTemplate();
return ipv6PrefixFor(tmp, mask);
}
- private P6 newIpv6Prefix(final String addr, final int mask) {
+ private Ipv6Prefix newIpv6Prefix(final String addr, final int mask) {
checkArgument(mask >= 0 && mask <= 128, "Invalid mask %s", mask);
return prefix6Factory.newInstance(addr + '/' + mask);
}
- public final @NonNull Entry<A6NZ, Integer> splitIpv6Prefix(final @NonNull P6 prefix) {
+ public final @NonNull Entry<Ipv6AddressNoZone, Integer> splitIpv6Prefix(final @NonNull Ipv6Prefix prefix) {
return splitPrefix(address6NoZoneFactory, ipv6PrefixString(prefix));
}
Integer.valueOf(str.substring(slash + 1)));
}
- public final byte @NonNull[] ipv6PrefixToBytes(final @NonNull P6 prefix) {
+ public final byte @NonNull[] ipv6PrefixToBytes(final @NonNull Ipv6Prefix prefix) {
final String str = ipv6PrefixString(prefix);
final byte[] bytes = new byte[Ipv6Utils.INET6_LENGTH + 1];
final int slash = str.lastIndexOf('/');
return sb.append('/').append(mask).toString();
}
- private P4 v4PrefixForShort(final byte @NonNull[] array, final int startOffset, final int size, final int mask) {
+ private @NonNull Ipv4Prefix v4PrefixForShort(final byte @NonNull[] array, final int startOffset, final int size,
+ final int mask) {
if (startOffset == 0 && size == Ipv4Utils.INET4_LENGTH && array.length == Ipv4Utils.INET4_LENGTH) {
// Easy case, fall back to non-short
return ipv4PrefixFor(array, mask);
return prefix4Factory.newInstance(sb.toString());
}
- private @NonNull A6 coerceIpv6Address(final @NonNull A addr) {
- final A6 ret = maybeIpv6Address(addr);
+ private @NonNull Ipv6Address coerceIpv6Address(final @NonNull IpAddress addr) {
+ final var ret = maybeIpv6Address(addr);
checkArgument(ret != null, "Address %s is neither IPv4 nor IPv6", addr);
return ret;
}
- private @NonNull A6NZ coerceIpv6AddressNoZone(final @NonNull ANZ addr) {
- final A6NZ ret = maybeIpv6AddressNoZone(addr);
+ private @NonNull Ipv6AddressNoZone coerceIpv6AddressNoZone(final @NonNull IpAddressNoZone addr) {
+ final var ret = maybeIpv6AddressNoZone(addr);
checkArgument(ret != null, "Address %s is neither IPv4 nor IPv6", addr);
return ret;
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.model.ietf.util.AbstractIetfInetUtil;
/**
* A set of utility methods to efficiently instantiate various ietf-inet-types DTOs.
*/
@Beta
-public final class IetfInetUtil extends AbstractIetfInetUtil<Ipv4Address, Ipv4AddressNoZone, Ipv4Prefix, Ipv6Address,
- Ipv6AddressNoZone, Ipv6Prefix, IpAddress, IpAddressNoZone, IpPrefix> {
+public final class IetfInetUtil extends AbstractIetfInetUtil {
public static final @NonNull IetfInetUtil INSTANCE = new IetfInetUtil();
private static final Pattern HOST_IPV4_PATTERN = Pattern.compile(
}
private IetfInetUtil() {
- super(Ipv4AddressNoZone.class, Ipv4Prefix.class, Ipv6AddressNoZone.class, Ipv6Prefix.class);
+ // Hidden on purpose
}
@Beta
*/
package org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil.INSTANCE;
-import java.lang.reflect.Constructor;
+import com.google.common.net.InetAddresses;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Map;
import org.junit.Test;
public class IetfInetUtilTest {
-
- @Test
- public void testIetfInetUtilConstructor() throws Exception {
- final Constructor<IetfInetUtil> constructor = IetfInetUtil.class.getDeclaredConstructor();
- assertFalse(constructor.isAccessible());
- constructor.setAccessible(true);
-
- final IetfInetUtil newInstance = constructor.newInstance();
- assertNotNull(newInstance);
- }
-
@Test
public void testIpv4Address() {
final Ipv4AddressNoZone ipv4Address = new Ipv4AddressNoZone("192.168.1.1");
final Ipv4Prefix ipv4Prefix = new Ipv4Prefix("192.0.2.1/24");
- final IpAddress ipAddress = IetfInetUtil.INSTANCE.ipv4Address(ipv4Address);
- final String ipv4AddressString = IetfInetUtil.INSTANCE.ipv4AddressString(ipv4Address);
- final Ipv4Address maybeIpv4Address = IetfInetUtil.INSTANCE.maybeIpv4Address(new IpAddress(ipv4Address));
- final IpPrefix ipPrefix = IetfInetUtil.INSTANCE.ipv4Prefix(ipv4Prefix);
- final String ipv4PrefixString = IetfInetUtil.INSTANCE.ipv4PrefixString(ipv4Prefix);
+ final IpAddress ipAddress = INSTANCE.ipv4Address(ipv4Address);
+ final String ipv4AddressString = INSTANCE.ipv4AddressString(ipv4Address);
+ final Ipv4Address maybeIpv4Address = INSTANCE.maybeIpv4Address(new IpAddress(ipv4Address));
+ final IpPrefix ipPrefix = INSTANCE.ipv4Prefix(ipv4Prefix);
+ final String ipv4PrefixString = INSTANCE.ipv4PrefixString(ipv4Prefix);
assertEquals(ipv4PrefixString, ipPrefix.getIpv4Prefix().getValue());
assertNotNull(maybeIpv4Address);
public void testIpv6Address() {
final Ipv6AddressNoZone ipv6Address = new Ipv6AddressNoZone("ABCD:EF01:2345:6789:ABCD:EF01:2345:6789");
final Ipv6Prefix ipv6Prefix = new Ipv6Prefix("ff00::/8");
- final IpAddress ipAddress = IetfInetUtil.INSTANCE.ipv6Address(ipv6Address);
- final String ipv6AddressString = IetfInetUtil.INSTANCE.ipv6AddressString(ipv6Address);
- final Ipv6Address maybeIpv6Address = IetfInetUtil.INSTANCE.maybeIpv6Address(new IpAddress(ipv6Address));
- final IpPrefix ipPrefix = IetfInetUtil.INSTANCE.ipv6Prefix(ipv6Prefix);
- final String ipv6PrefixString = IetfInetUtil.INSTANCE.ipv6PrefixString(ipv6Prefix);
+ final IpAddress ipAddress = INSTANCE.ipv6Address(ipv6Address);
+ final String ipv6AddressString = INSTANCE.ipv6AddressString(ipv6Address);
+ final Ipv6Address maybeIpv6Address = INSTANCE.maybeIpv6Address(new IpAddress(ipv6Address));
+ final IpPrefix ipPrefix = INSTANCE.ipv6Prefix(ipv6Prefix);
+ final String ipv6PrefixString = INSTANCE.ipv6PrefixString(ipv6Prefix);
assertEquals(ipv6PrefixString, ipPrefix.getIpv6Prefix().getValue());
assertNotNull(maybeIpv6Address);
@Test
public void testAddressToString() {
- assertEquals(new Ipv4Prefix("1.2.3.4/8"), IetfInetUtil.INSTANCE.ipv4PrefixFor(new Ipv4Address("1.2.3.4%1"), 8));
- assertEquals(new Ipv6Prefix("ff00::/8"), IetfInetUtil.INSTANCE.ipv6PrefixFor(new Ipv6Address("ff00::%bar"), 8));
+ assertEquals(new Ipv4Prefix("1.2.3.4/8"), INSTANCE.ipv4PrefixFor(new Ipv4Address("1.2.3.4%1"), 8));
+ assertEquals(new Ipv6Prefix("ff00::/8"), INSTANCE.ipv6PrefixFor(new Ipv6Address("ff00::%bar"), 8));
}
@Test
public void testIpv4ZoneStripping() {
final Ipv4AddressNoZone noZone = new Ipv4AddressNoZone("1.2.3.4");
- assertSame(noZone, IetfInetUtil.INSTANCE.ipv4AddressNoZoneFor(noZone));
+ assertSame(noZone, INSTANCE.ipv4AddressNoZoneFor(noZone));
final Ipv4Address withoutZone = new Ipv4Address(noZone);
- final Ipv4AddressNoZone stripped = IetfInetUtil.INSTANCE.ipv4AddressNoZoneFor(withoutZone);
+ final Ipv4AddressNoZone stripped = INSTANCE.ipv4AddressNoZoneFor(withoutZone);
assertSame(withoutZone.getValue(), stripped.getValue());
- assertEquals(noZone, IetfInetUtil.INSTANCE.ipv4AddressNoZoneFor(new Ipv4Address("1.2.3.4%1")));
+ assertEquals(noZone, INSTANCE.ipv4AddressNoZoneFor(new Ipv4Address("1.2.3.4%1")));
}
@Test
public void testIpv6ZoneStripping() {
final Ipv6AddressNoZone noZone = new Ipv6AddressNoZone("ff00::");
- assertSame(noZone, IetfInetUtil.INSTANCE.ipv6AddressNoZoneFor(noZone));
+ assertSame(noZone, INSTANCE.ipv6AddressNoZoneFor(noZone));
final Ipv6Address withoutZone = new Ipv6Address(noZone);
- final Ipv6AddressNoZone stripped = IetfInetUtil.INSTANCE.ipv6AddressNoZoneFor(withoutZone);
+ final Ipv6AddressNoZone stripped = INSTANCE.ipv6AddressNoZoneFor(withoutZone);
assertSame(withoutZone.getValue(), stripped.getValue());
- assertEquals(noZone, IetfInetUtil.INSTANCE.ipv6AddressNoZoneFor(new Ipv6Address("ff00::%1")));
+ assertEquals(noZone, INSTANCE.ipv6AddressNoZoneFor(new Ipv6Address("ff00::%1")));
+ }
+
+ @Test
+ public void testIpToBytesAndBack() {
+ assertV4Equals("1.2.3.4");
+ assertV4Equals("12.23.34.45");
+ assertV4Equals("255.254.253.252");
+ assertV4Equals("128.16.0.127");
+
+ assertV4Equals("1.2.3.4", "%5");
+ assertV4Equals("12.23.34.45", "%5");
+ assertV4Equals("255.254.253.252", "%5");
+ assertV4Equals("128.16.0.127", "%5");
+
+ assertEquals(new IpAddress(new Ipv4Address("1.2.3.4")),
+ INSTANCE.ipAddressFor(INSTANCE.ipv4AddressBytes(new Ipv4Address("1.2.3.4"))));
+ assertNotEquals(new IpAddress(new Ipv4Address("2.3.4.5")),
+ INSTANCE.ipAddressFor(INSTANCE.ipv4AddressBytes(new Ipv4Address("1.2.3.4"))));
+
+ assertEquals(new IpAddress(new Ipv6Address("fe80::2002:b3ff:fe1e:8329")),
+ INSTANCE.ipAddressFor(INSTANCE.ipv6AddressBytes(new Ipv6Address("FE80::2002:B3FF:FE1E:8329"))));
+ assertNotEquals(new IpAddress(new Ipv6Address("feff::2002:b3ff:fe1e:8329")),
+ INSTANCE.ipAddressFor(INSTANCE.ipv6AddressBytes(new Ipv6Address("FE80::2002:B3FF:FE1E:8329"))));
+
+ assertEquals(new IpAddress(new Ipv4Address("1.2.3.4")),
+ INSTANCE.ipAddressFor(INSTANCE.inetAddressFor(new IpAddress(new Ipv4Address("1.2.3.4")))));
+ assertNotEquals(new IpAddress(new Ipv4Address("2.3.4.5")),
+ INSTANCE.ipAddressFor(INSTANCE.inetAddressFor(new IpAddress(new Ipv4Address("1.2.3.4")))));
+
+ assertEquals(new IpAddress(new Ipv6Address("fe80::2002:b3ff:fe1e:8329")),
+ INSTANCE.ipAddressFor(INSTANCE.inetAddressFor(
+ new IpAddress(new Ipv6Address("FE80::2002:B3FF:FE1E:8329")))));
+ assertNotEquals(new IpAddress(new Ipv6Address("FEFF::2002:B3FF:FE1E:8329")),
+ INSTANCE.ipAddressFor(INSTANCE.inetAddressFor(
+ new IpAddress(new Ipv6Address("FE80::2002:B3FF:FE1E:8329")))));
+ }
+
+ @Test
+ public void illegalArrayLengthForAddressTest() {
+ final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+ () -> INSTANCE.ipAddressFor(new byte[] { 0, 0, 0 }));
+ assertEquals("Invalid array length 3", ex.getMessage());
+ }
+
+ @Test
+ public void unhandledAddressTest() {
+ final InetAddress adr = mock(InetAddress.class);
+ doReturn("testAddress").when(adr).toString();
+ final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+ () -> INSTANCE.ipAddressFor(adr));
+ assertEquals("Unhandled address testAddress", ex.getMessage());
+ }
+
+ @Test
+ public void illegalArrayLengthforPrefixTest() {
+ final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+ () -> INSTANCE.ipPrefixFor(new byte[] { 0, 0, 0 }, 0));
+ assertEquals("Invalid array length 3", ex.getMessage());
+ }
+
+ @Test
+ public void illegalAddressforPrefixTest() {
+ final InetAddress adr = mock(InetAddress.class);
+ doReturn("testAddress").when(adr).toString();
+
+ final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+ () -> INSTANCE.ipPrefixFor(adr, 0));
+ assertEquals("Unhandled address testAddress", ex.getMessage());
}
+
+ @Test
+ public void ipv4Tests() {
+ assertEquals("1.2.3.4", INSTANCE.ipv4AddressFrom(new Ipv4Prefix("1.2.3.4/16")).getValue());
+ final var ipv4address = new Ipv4Address("1.2.3.4");
+ final var ipAddress = new IpAddress(ipv4address);
+ assertEquals("1.2.3.4/32", INSTANCE.ipv4PrefixFor(INSTANCE.ipv4AddressBytes(ipv4address)).getValue());
+ assertEquals("1.2.3.4/32", INSTANCE.ipv4PrefixFor(INSTANCE.inetAddressFor(ipAddress)).getValue());
+ assertEquals("1.2.3.4/32", INSTANCE.ipv4PrefixFor(ipv4address).getValue());
+ assertEquals("1.2.3.4/16", INSTANCE.ipv4PrefixFor(ipv4address, 16).getValue());
+
+ assertEquals("0.0.0.0/0", INSTANCE.ipv4PrefixForShort(INSTANCE.ipv4AddressBytes(ipv4address), 0).getValue());
+ assertEquals("1.2.3.4/32", INSTANCE.ipv4PrefixForShort(INSTANCE.ipv4AddressBytes(ipv4address), 32).getValue());
+ assertEquals("0.0.0.0/0", INSTANCE.ipv4PrefixForShort(INSTANCE.ipv4AddressBytes(ipv4address), 0, 0).getValue());
+ assertEquals("1.2.3.4/32",
+ INSTANCE.ipv4PrefixForShort(INSTANCE.ipv4AddressBytes(ipv4address), 0, 32).getValue());
+ assertEquals("2.3.4.5/32", INSTANCE.ipv4PrefixForShort(new byte[] { 1, 2, 3, 4, 5 }, 1, 32).getValue());
+ assertEquals("1.0.0.0/1", INSTANCE.ipv4PrefixForShort(new byte[] { 1, 2, 3, 4, 5 }, 0, 1).getValue());
+
+ final var ipv4Prefix = new Ipv4Prefix("1.2.3.4/16");
+ assertEquals("1.2.3.4", INSTANCE.splitIpv4Prefix(ipv4Prefix).getKey().getValue());
+ assertEquals((Integer) 16, INSTANCE.splitIpv4Prefix(ipv4Prefix).getValue());
+ assertArrayEquals(new byte[] { 1,2,3,4,16 }, INSTANCE.ipv4PrefixToBytes(ipv4Prefix));
+ }
+
+ @Test
+ public void ipv6Tests() {
+ assertEquals("::0", INSTANCE.ipv6AddressFrom(new Ipv6Prefix("::0/128")).getValue());
+ final var ipv6address = new Ipv6Address("::0");
+ final var ipAddress = new IpAddress(ipv6address);
+
+ assertEquals("::/128", INSTANCE.ipv6PrefixFor(INSTANCE.ipv6AddressBytes(ipv6address)).getValue());
+ assertEquals("::/128", INSTANCE.ipv6PrefixFor(INSTANCE.inetAddressFor(ipAddress)).getValue());
+ assertEquals("::0/128", INSTANCE.ipv6PrefixFor(ipv6address).getValue());
+ assertEquals("::0/16", INSTANCE.ipv6PrefixFor(ipv6address, 16).getValue());
+
+ assertEquals("::0/0", INSTANCE.ipv6PrefixForShort(INSTANCE.ipv6AddressBytes(ipv6address), 0).getValue());
+ assertEquals("::/64", INSTANCE.ipv6PrefixForShort(INSTANCE.ipv6AddressBytes(ipv6address), 64).getValue());
+ assertEquals("::0/0", INSTANCE.ipv6PrefixForShort(INSTANCE.ipv6AddressBytes(ipv6address), 0, 0).getValue());
+ assertEquals("::/32", INSTANCE.ipv6PrefixForShort(INSTANCE.ipv6AddressBytes(ipv6address), 0, 32).getValue());
+
+ assertEquals(Map.entry(new Ipv6Address("::"), 32), INSTANCE.splitIpv6Prefix(new Ipv6Prefix("::/32")));
+ assertArrayEquals(new byte[] { 0, 10, 0, 0, 0, 0, 0, 0, 0, 11, 0, 12, 0, 13, 0, 14, 64 },
+ INSTANCE.ipv6PrefixToBytes(new Ipv6Prefix("A::B:C:D:E/64")));
+
+ // verify that an IPv4-mapped IPv6 address gets parsed as an IPv6 address
+ assertEquals("::ffff:ab0:eb", INSTANCE.ipv6AddressFor(
+ new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (byte) 0xff, (byte) 0xff, 0x0a, (byte) 0xb0, 0, (byte) 0xeb})
+ .getValue());
+ }
+
+ @Test
+ public void prefixTest() {
+ assertEquals(new IpPrefix(new Ipv4Prefix("0.0.0.0/16")),
+ INSTANCE.ipPrefixFor(INSTANCE.inetAddressFor(new IpAddress(new Ipv4Address("0.0.0.0"))), 16));
+ assertEquals(new IpPrefix(new Ipv6Prefix("::/64")),
+ INSTANCE.ipPrefixFor(INSTANCE.inetAddressFor(new IpAddress(new Ipv6Address("::"))), 64));
+
+ assertEquals(new IpPrefix(new Ipv4Prefix("0.0.0.0/16")),
+ INSTANCE.ipPrefixFor(new byte[] { 0, 0, 0, 0 }, 16));
+ assertEquals(new IpPrefix(new Ipv6Prefix("::/64")),
+ INSTANCE.ipPrefixFor(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 64));
+ }
+
+ @Test
+ public void inetAddressTest() {
+ assertThat(INSTANCE.inetAddressFor(new IpAddress(new Ipv4Address("1.2.3.4"))),
+ instanceOf(Inet4Address.class));
+ assertThat(INSTANCE.inetAddressFor(new IpAddress(new Ipv6Address("FE80::2002:B3FF:FE1E:8329"))),
+ instanceOf(Inet6Address.class));
+ }
+
+ @Test
+ public void inet4AddressForWithExceptionTest() {
+ final Ipv4Address ipClass = mock(Ipv4Address.class);
+ doReturn("testClass").when(ipClass).toString();
+ doAnswer(inv -> {
+ throw new UnknownHostException();
+ }).when(ipClass).getValue();
+
+ final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+ () -> INSTANCE.inet4AddressFor(ipClass));
+ assertEquals("Invalid address testClass", ex.getMessage());
+ }
+
+ @Test
+ public void inet6AddressForWithExceptionTest() {
+ final Ipv6Address ipClass = mock(Ipv6Address.class);
+ doReturn("testClass").when(ipClass).toString();
+ doAnswer(inv -> {
+ throw new UnknownHostException();
+ }).when(ipClass).getValue();
+
+ final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+ () -> INSTANCE.inet6AddressFor(ipClass));
+ assertEquals("Invalid address testClass", ex.getMessage());
+ }
+
+ @Test
+ public void testIpv4AddressForBits() {
+ assertEquals("1.2.3.4", INSTANCE.ipv4AddressFor(0x01020304).getValue());
+ assertEquals("255.255.255.255", INSTANCE.ipv4AddressFor(0xFFFFFFFF).getValue());
+ }
+
+ @Test
+ public void testIpv4AddressBits() {
+ assertEquals(0x01020304, INSTANCE.ipv4AddressBits(new Ipv4Address("1.2.3.4")));
+ assertEquals(0xFFFFFFFF, INSTANCE.ipv4AddressBits(new Ipv4Address("255.255.255.255")));
+ }
+
+ @Test
+ public void testIpv4AddressNoZoneBits() {
+ assertEquals(0x01020304, INSTANCE.ipv4AddressNoZoneBits(new Ipv4AddressNoZone("1.2.3.4")));
+ assertEquals(0xFFFFFFFF, INSTANCE.ipv4AddressNoZoneBits(new Ipv4AddressNoZone("255.255.255.255")));
+ }
+
+ private static void assertV4Equals(final String literal, final String append) {
+ final byte[] expected = InetAddresses.forString(literal).getAddress();
+ final byte[] actual = INSTANCE.ipv4AddressBytes(new Ipv4Address(literal + append));
+ assertArrayEquals(expected, actual);
+ }
+
+ private static void assertV4Equals(final String literal) {
+ assertV4Equals(literal, "");
+ }
+
}
Code Review / mdsal.git / commitdiff