[Git][java-team/wildfly-common][master] 3 commits: New upstream version 1.4.0
Markus Koschany
gitlab at salsa.debian.org
Tue May 15 13:56:26 BST 2018
Markus Koschany pushed to branch master at Debian Java Maintainers / wildfly-common
Commits:
15f73065 by Markus Koschany at 2018-05-15T14:51:48+02:00
New upstream version 1.4.0
- - - - -
679229ee by Markus Koschany at 2018-05-15T14:51:52+02:00
Update upstream source from tag 'upstream/1.4.0'
Update to upstream version '1.4.0'
with Debian dir fd2a13c2133a9efe0c2705fa51a8b3e6f1505946
- - - - -
39597b3b by Markus Koschany at 2018-05-15T14:53:15+02:00
Update changelog
- - - - -
7 changed files:
- debian/changelog
- pom.xml
- src/main/java/org/wildfly/common/_private/CommonMessages.java
- src/main/java/org/wildfly/common/function/Functions.java
- src/main/java/org/wildfly/common/math/HashMath.java
- src/main/java/org/wildfly/common/net/Inet.java
- src/test/java/org/wildfly/common/math/HashMathTestCase.java
Changes:
=====================================
debian/changelog
=====================================
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+wildfly-common (1.4.0-1) unstable; urgency=medium
+
+ * New upstream version 1.4.0.
+
+ -- Markus Koschany <apo at debian.org> Tue, 15 May 2018 14:53:05 +0200
+
wildfly-common (1.3.2-1) unstable; urgency=medium
* New upstream version 1.3.2.
=====================================
pom.xml
=====================================
--- a/pom.xml
+++ b/pom.xml
@@ -25,7 +25,7 @@
<groupId>org.wildfly.common</groupId>
<artifactId>wildfly-common</artifactId>
- <version>1.3.2.Final</version>
+ <version>1.4.0.Final</version>
<parent>
<groupId>org.jboss</groupId>
@@ -197,6 +197,9 @@
<configuration>
<archive>
<manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+ <manifestEntries>
+ <Multi-Release>true</Multi-Release>
+ </manifestEntries>
</archive>
</configuration>
</plugin>
=====================================
src/main/java/org/wildfly/common/_private/CommonMessages.java
=====================================
--- a/src/main/java/org/wildfly/common/_private/CommonMessages.java
+++ b/src/main/java/org/wildfly/common/_private/CommonMessages.java
@@ -80,6 +80,9 @@ public interface CommonMessages {
@Message(id = 12, value = "Invalid address length of %d; must be 4 or 16")
IllegalArgumentException invalidAddressBytes(int length);
+ @Message(id = 13, value = "Invalid address string \"%s\"")
+ IllegalArgumentException invalidAddress(String address);
+
// execution path validation
@Message(id = 100, value = "Method \"%s\" of class \"%s\" is not implemented")
=====================================
src/main/java/org/wildfly/common/function/Functions.java
=====================================
--- a/src/main/java/org/wildfly/common/function/Functions.java
+++ b/src/main/java/org/wildfly/common/function/Functions.java
@@ -277,6 +277,54 @@ public final class Functions {
return new ExceptionConsumerRunnable<T, E>(consumer, param);
}
+ /**
+ * Get a consumer which discards the values it is given.
+ *
+ * @param <T> the parameter type
+ * @return the discarding consumer
+ */
+ @SuppressWarnings("unchecked")
+ public static <T> Consumer<T> discardingConsumer() {
+ return DiscardingConsumer.INSTANCE;
+ }
+
+ /**
+ * Get a consumer which discards the values it is given.
+ *
+ * @param <T> the parameter type
+ * @param <E> the exception type
+ * @return the discarding consumer
+ */
+ @SuppressWarnings("unchecked")
+ public static <T, E extends Exception> ExceptionConsumer<T, E> discardingExceptionConsumer() {
+ return DiscardingConsumer.INSTANCE;
+ }
+
+ /**
+ * Get a consumer which discards the values it is given.
+ *
+ * @param <T> the first parameter type
+ * @param <U> the second parameter type
+ * @return the discarding consumer
+ */
+ @SuppressWarnings("unchecked")
+ public static <T, U> BiConsumer<T, U> discardingBiConsumer() {
+ return DiscardingBiConsumer.INSTANCE;
+ }
+
+ /**
+ * Get a consumer which discards the values it is given.
+ *
+ * @param <T> the first parameter type
+ * @param <U> the second parameter type
+ * @param <E> the exception type
+ * @return the discarding consumer
+ */
+ @SuppressWarnings("unchecked")
+ public static <T, U, E extends Exception> ExceptionBiConsumer<T, U, E> discardingExceptionBiConsumer() {
+ return DiscardingBiConsumer.INSTANCE;
+ }
+
static class RunnableConsumer implements Consumer<Runnable> {
static final Consumer<Runnable> INSTANCE = new RunnableConsumer();
@@ -512,4 +560,24 @@ public final class Functions {
return String.format("%s(%s)", consumer, param);
}
}
+
+ static class DiscardingConsumer<T, E extends Exception> implements Consumer<T>, ExceptionConsumer<T, E> {
+ static final DiscardingConsumer INSTANCE = new DiscardingConsumer();
+
+ private DiscardingConsumer() {
+ }
+
+ public void accept(final T t) {
+ }
+ }
+
+ static class DiscardingBiConsumer<T, U, E extends Exception> implements BiConsumer<T, U>, ExceptionBiConsumer<T, U, E> {
+ static final DiscardingBiConsumer INSTANCE = new DiscardingBiConsumer();
+
+ private DiscardingBiConsumer() {
+ }
+
+ public void accept(final T t, final U u) {
+ }
+ }
}
=====================================
src/main/java/org/wildfly/common/math/HashMath.java
=====================================
--- a/src/main/java/org/wildfly/common/math/HashMath.java
+++ b/src/main/java/org/wildfly/common/math/HashMath.java
@@ -18,6 +18,8 @@
package org.wildfly.common.math;
+import org.wildfly.common.Assert;
+
/**
* Routines which are useful for hashcode computation, among other things.
*
@@ -31,6 +33,18 @@ public final class HashMath {
}
/**
+ * Round the given value up to the next positive power of two.
+ *
+ * @param value the value (must not be negative and must be less than or equal to {@code 2^31})
+ * @return the rounded power of two value
+ */
+ public static int roundToPowerOfTwo(int value) {
+ Assert.checkMinimumParameter("value", 0, value);
+ Assert.checkMaximumParameter("value", 0x4000_0000, value);
+ return value <= 1 ? value : Integer.highestOneBit(value - 1) << 1;
+ }
+
+ /**
* A hash function which combines an accumulated hash with a next hash such that {@code f(f(k, p2, b), p1, a) ≠ₙ f(f(k, p1, a), p2, b)}.
* This function is suitable for object chains whose order affects the overall equality of the hash code.
* <p>
=====================================
src/main/java/org/wildfly/common/net/Inet.java
=====================================
--- a/src/main/java/org/wildfly/common/net/Inet.java
+++ b/src/main/java/org/wildfly/common/net/Inet.java
@@ -20,12 +20,14 @@ package org.wildfly.common.net;
import static java.security.AccessController.doPrivileged;
+import java.lang.reflect.Array;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
+import java.net.URI;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.security.PrivilegedAction;
@@ -98,6 +100,51 @@ public final class Inet {
}
/**
+ * Get a string representation of the given address which is suitable for use as the host component of a URL.
+ *
+ * @param inetAddress the address (must not be {@code null})
+ * @param useHostNameIfPresent {@code true} to preserve the host name string in the address, {@code false} to always give
+ * an IP address string
+ * @return the string representation (not {@code null})
+ */
+ public static String toURLString(InetAddress inetAddress, boolean useHostNameIfPresent) {
+ Assert.checkNotNullParam("inetAddress", inetAddress);
+ if (useHostNameIfPresent) {
+ final String hostName = getHostNameIfResolved(inetAddress);
+ if (hostName != null) {
+ if (inetAddress instanceof Inet6Address && isInet6Address(hostName)) {
+ return "[" + hostName + "]";
+ } else {
+ // return it even if it's an IP address or whatever
+ return hostName;
+ }
+ }
+ }
+ if (inetAddress instanceof Inet6Address) {
+ return "[" + toOptimalString(inetAddress) + "]";
+ } else {
+ return toOptimalString(inetAddress);
+ }
+ }
+
+ /**
+ * Get a string representation of the given address bytes which is suitable for use as the host component of a URL.
+ *
+ * @param addressBytes the address bytes (must not be {@code null})
+ * @return the string representation (not {@code null})
+ */
+ public static String toURLString(byte[] addressBytes) {
+ Assert.checkNotNullParam("addressBytes", addressBytes);
+ if (addressBytes.length == 4) {
+ return (addressBytes[0] & 0xff) + "." + (addressBytes[1] & 0xff) + "." + (addressBytes[2] & 0xff) + "." + (addressBytes[3] & 0xff);
+ } else if (addressBytes.length == 16) {
+ return "[" + toOptimalStringV6(addressBytes) + "]";
+ } else {
+ throw CommonMessages.msg.invalidAddressBytes(addressBytes.length);
+ }
+ }
+
+ /**
* Get the IPv6 equivalent of the given address. If the address is IPv4 then it is returned as a compatibility
* address.
*
@@ -140,6 +187,142 @@ public final class Inet {
}
/**
+ * Get a resolved socket address from the given URI.
+ *
+ * @param uri the URI (must not be {@code null})
+ * @param defaultPort the default port to use if none is given (must be in the range {@code 1 ≤ n ≤ 65535}
+ * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+ * @return the socket address, or {@code null} if the URI does not have a host component
+ * @throws UnknownHostException if address resolution failed
+ */
+ public static InetSocketAddress getResolved(URI uri, int defaultPort, Class<? extends InetAddress> addressType) throws UnknownHostException {
+ Assert.checkNotNullParam("uri", uri);
+ Assert.checkMinimumParameter("defaultPort", 1, defaultPort);
+ Assert.checkMaximumParameter("defaultPort", 65535, defaultPort);
+ Assert.checkNotNullParam("addressType", addressType);
+ final String uriHost = uri.getHost();
+ if (uriHost == null) {
+ return null;
+ }
+ final InetAddress resolved = getAddressByNameAndType(uriHost, addressType);
+ final int uriPort = uri.getPort();
+ return uriPort != - 1 ? new InetSocketAddress(resolved, uriPort) : new InetSocketAddress(resolved, defaultPort);
+ }
+
+ /**
+ * Get the resolved socket address from the given URI.
+ *
+ * @param uri the URI (must not be {@code null})
+ * @param defaultPort the default port to use if none is given (must be in the range {@code 1 ≤ n ≤ 65535}
+ * @return the socket address, or {@code null} if the URI does not have a host component
+ * @throws UnknownHostException if address resolution failed
+ */
+ public static InetSocketAddress getResolved(URI uri, int defaultPort) throws UnknownHostException {
+ return getResolved(uri, defaultPort, InetAddress.class);
+ }
+
+ /**
+ * Get a copy of the given socket address, but with a resolved address component.
+ *
+ * @param address the (possibly unresolved) address (must not be {@code null})
+ * @return the resolved address (not {@code null})
+ * @throws UnknownHostException if address resolution failed
+ */
+ public static InetSocketAddress getResolved(InetSocketAddress address) throws UnknownHostException {
+ return getResolved(address, InetAddress.class);
+ }
+
+ /**
+ * Get a copy of the given socket address, but with a resolved address component of the given type.
+ *
+ * @param address the (possibly unresolved) address (must not be {@code null})
+ * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+ * @return the resolved address (not {@code null})
+ * @throws UnknownHostException if address resolution failed, or if no addresses of the given type were found, or
+ * if the given address was already resolved but is not of the given address type
+ */
+ public static InetSocketAddress getResolved(InetSocketAddress address, Class<? extends InetAddress> addressType) throws UnknownHostException {
+ Assert.checkNotNullParam("address", address);
+ Assert.checkNotNullParam("addressType", addressType);
+ if (! address.isUnresolved()) {
+ if (! addressType.isInstance(address.getAddress())) {
+ // the address part does not match
+ throw new UnknownHostException(address.getHostString());
+ }
+ return address;
+ }
+ return new InetSocketAddress(getAddressByNameAndType(address.getHostString(), addressType), address.getPort());
+ }
+
+ /**
+ * Resolve the given host name, returning the first answer with the given address type.
+ *
+ * @param hostName the host name to resolve (must not be {@code null})
+ * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+ * @param <T> the type of the {@code InetAddress} to search for
+ * @return the resolved address (not {@code null})
+ * @throws UnknownHostException if address resolution failed or if no addresses of the given type were found
+ */
+ public static <T extends InetAddress> T getAddressByNameAndType(String hostName, Class<T> addressType) throws UnknownHostException {
+ Assert.checkNotNullParam("hostName", hostName);
+ Assert.checkNotNullParam("addressType", addressType);
+ if (addressType == InetAddress.class) {
+ return addressType.cast(InetAddress.getByName(hostName));
+ }
+ for (InetAddress inetAddress : InetAddress.getAllByName(hostName)) {
+ if (addressType.isInstance(inetAddress)) {
+ return addressType.cast(inetAddress);
+ }
+ }
+ // no i18n here because this is a "standard" exception
+ throw new UnknownHostException(hostName);
+ }
+
+ /**
+ * Resolve the given host name, returning all answers with the given address type.
+ *
+ * @param hostName the host name to resolve (must not be {@code null})
+ * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+ * @param <T> the type of the {@code InetAddress} to search for
+ * @return the resolved addresses (not {@code null})
+ * @throws UnknownHostException if address resolution failed or if no addresses of the given type were found
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends InetAddress> T[] getAllAddressesByNameAndType(String hostName, Class<T> addressType) throws UnknownHostException {
+ Assert.checkNotNullParam("hostName", hostName);
+ Assert.checkNotNullParam("addressType", addressType);
+ if (addressType == InetAddress.class) {
+ // safe because T == InetAddress
+ return (T[]) InetAddress.getAllByName(hostName);
+ }
+ final InetAddress[] addresses = InetAddress.getAllByName(hostName);
+ final int length = addresses.length;
+ int count = 0;
+ for (InetAddress inetAddress : addresses) {
+ if (addressType.isInstance(inetAddress)) {
+ count ++;
+ }
+ }
+ if (count == 0) {
+ // no i18n here because this is a "standard" exception
+ throw new UnknownHostException(hostName);
+ }
+ final T[] newArray = (T[]) Array.newInstance(addressType, count);
+ if (count == length) {
+ //noinspection SuspiciousSystemArraycopy
+ System.arraycopy(addresses, 0, newArray, 0, length);
+ } else {
+ int idx = 0;
+ for (InetAddress inetAddress : addresses) {
+ if (addressType.isInstance(inetAddress)) {
+ newArray[idx] = addressType.cast(inetAddress);
+ }
+ }
+ }
+ return newArray;
+ }
+
+ /**
* Get an IPv4 address from four integer segments. Each segment must be between 0 and 255.
*
* @param s1 the first segment
@@ -238,37 +421,77 @@ public final class Inet {
/**
* Parse an IPv6 address into an {@code Inet6Address} object.
*
- * @param string the address to parse
+ * @param address the address to parse
* @return the parsed address, or {@code null} if the address is not valid
*/
- public static Inet6Address parseInet6Address(String string) {
- final byte[] bytes = parseInet6AddressToBytes(string);
+ public static Inet6Address parseInet6Address(String address) {
+ return parseInet6Address(address, null);
+ }
+
+ /**
+ * Parse an IPv6 address into an {@code Inet6Address} object.
+ *
+ * @param address the address to parse (must not be {@code null})
+ * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+ * the address
+ * @return the parsed address, or {@code null} if the address is not valid
+ */
+ public static Inet6Address parseInet6Address(String address, String hostName) {
+ final byte[] bytes = parseInet6AddressToBytes(address);
if (bytes == null) {
return null;
}
int scopeId = 0;
- Inet6Address address;
+ Inet6Address inetAddress;
try {
- address = Inet6Address.getByAddress(string, bytes, 0);
+ inetAddress = Inet6Address.getByAddress(hostName == null ? toOptimalStringV6(bytes) : hostName, bytes, 0);
} catch (UnknownHostException e) {
// not possible
throw new IllegalStateException(e);
}
- final int pctIdx = string.indexOf('%');
+ final int pctIdx = address.indexOf('%');
if (pctIdx != -1) {
- scopeId = getScopeId(string.substring(pctIdx + 1), address);
+ scopeId = getScopeId(address.substring(pctIdx + 1), inetAddress);
if (scopeId == 0) {
// address not valid after all...
return null;
}
try {
- address = Inet6Address.getByAddress(string, bytes, scopeId);
+ inetAddress = Inet6Address.getByAddress(hostName == null ? toOptimalStringV6(bytes) : hostName, bytes, scopeId);
} catch (UnknownHostException e) {
// not possible
throw new IllegalStateException(e);
}
}
- return address;
+ return inetAddress;
+ }
+
+ /**
+ * Parse an IPv6 address into an {@code Inet6Address} object, throwing an exception on failure.
+ *
+ * @param address the address to parse
+ * @return the parsed address (not {@code null})
+ * @throws IllegalArgumentException if the address is not valid
+ */
+ public static Inet6Address parseInet6AddressOrFail(String address) {
+ final Inet6Address result = parseInet6Address(address, null);
+ if (result == null) throw CommonMessages.msg.invalidAddress(address);
+ return result;
+ }
+
+ /**
+ * Parse an IPv6 address into an {@code Inet6Address} object.
+ *
+ * @param address the address to parse (must not be {@code null})
+ * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+ * the address
+ * @return the parsed address (not {@code null})
+ * @throws IllegalArgumentException if the address is not valid
+ */
+ public static Inet6Address parseInet6AddressOrFail(String address, String hostName) {
+ final Inet6Address result = parseInet6Address(address, hostName);
+ if (result == null) throw CommonMessages.msg.invalidAddress(address);
+ return result;
}
/**
@@ -288,12 +511,24 @@ public final class Inet {
* @return the parsed address, or {@code null} if the address is not valid
*/
public static Inet4Address parseInet4Address(String address) {
+ return parseInet4Address(address, null);
+ }
+
+ /**
+ * Parse an IPv4 address into an {@code Inet4Address} object.
+ *
+ * @param address the address to parse
+ * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+ * the address
+ * @return the parsed address, or {@code null} if the address is not valid
+ */
+ public static Inet4Address parseInet4Address(String address, String hostName) {
final byte[] bytes = parseInet4AddressToBytes(address);
if (bytes == null) {
return null;
}
try {
- return (Inet4Address) Inet4Address.getByAddress(address, bytes);
+ return (Inet4Address) Inet4Address.getByAddress(hostName == null ? toOptimalString(bytes) : hostName, bytes);
} catch (UnknownHostException e) {
// not possible
throw new IllegalStateException(e);
@@ -301,21 +536,89 @@ public final class Inet {
}
/**
+ * Parse an IPv4 address into an {@code Inet4Address} object, throwing an exception on failure.
+ *
+ * @param address the address to parse
+ * @return the parsed address (not {@code null})
+ * @throws IllegalArgumentException if the address is not valid
+ */
+ public static Inet4Address parseInet4AddressOrFail(String address) {
+ final Inet4Address result = parseInet4Address(address, null);
+ if (result == null) throw CommonMessages.msg.invalidAddress(address);
+ return result;
+ }
+
+ /**
+ * Parse an IPv4 address into an {@code Inet4Address} object.
+ *
+ * @param address the address to parse (must not be {@code null})
+ * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+ * the address
+ * @return the parsed address (not {@code null})
+ * @throws IllegalArgumentException if the address is not valid
+ */
+ public static Inet4Address parseInet4AddressOrFail(String address, String hostName) {
+ final Inet4Address result = parseInet4Address(address, hostName);
+ if (result == null) throw CommonMessages.msg.invalidAddress(address);
+ return result;
+ }
+
+ /**
* Parse an IP address into an {@code InetAddress} object.
*
* @param address the address to parse
* @return the parsed address, or {@code null} if the address is not valid
*/
public static InetAddress parseInetAddress(String address) {
+ return parseInetAddress(address, null);
+ }
+
+ /**
+ * Parse an IP address into an {@code InetAddress} object.
+ *
+ * @param address the address to parse
+ * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+ * the address
+ * @return the parsed address, or {@code null} if the address is not valid
+ */
+ public static InetAddress parseInetAddress(String address, String hostName) {
// simple heuristic
if (address.indexOf(':') != -1) {
- return parseInet6Address(address);
+ return parseInet6Address(address, hostName);
} else {
- return parseInet4Address(address);
+ return parseInet4Address(address, hostName);
}
}
/**
+ * Parse an IP address into an {@code InetAddress} object, throwing an exception on failure.
+ *
+ * @param address the address to parse
+ * @return the parsed address (not {@code null})
+ * @throws IllegalArgumentException if the address is not valid
+ */
+ public static InetAddress parseInetAddressOrFail(String address) {
+ final InetAddress result = parseInetAddress(address, null);
+ if (result == null) throw CommonMessages.msg.invalidAddress(address);
+ return result;
+ }
+
+ /**
+ * Parse an IP address into an {@code InetAddress} object.
+ *
+ * @param address the address to parse (must not be {@code null})
+ * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+ * the address
+ * @return the parsed address (not {@code null})
+ * @throws IllegalArgumentException if the address is not valid
+ */
+ public static InetAddress parseInetAddressOrFail(String address, String hostName) {
+ final InetAddress result = parseInetAddress(address, hostName);
+ if (result == null) throw CommonMessages.msg.invalidAddress(address);
+ return result;
+ }
+
+ /**
* Parse a CIDR address into a {@code CidrAddress} object.
*
* @param address the address to parse
=====================================
src/test/java/org/wildfly/common/math/HashMathTestCase.java
=====================================
--- a/src/test/java/org/wildfly/common/math/HashMathTestCase.java
+++ b/src/test/java/org/wildfly/common/math/HashMathTestCase.java
@@ -19,14 +19,33 @@
package org.wildfly.common.math;
import static org.junit.Assert.*;
-import static org.wildfly.common.math.HashMath.multiHashOrdered;
-import static org.wildfly.common.math.HashMath.multiHashUnordered;
+import static org.wildfly.common.math.HashMath.*;
import org.junit.Test;
public class HashMathTestCase {
@Test
+ public void testPowerOfTwo() {
+ assertEquals(0, roundToPowerOfTwo(0));
+ assertEquals(1, roundToPowerOfTwo(1));
+ assertEquals(4, roundToPowerOfTwo(3));
+ assertEquals(4, roundToPowerOfTwo(4));
+ assertEquals(8, roundToPowerOfTwo(5));
+ assertEquals(8, roundToPowerOfTwo(7));
+ assertEquals(8, roundToPowerOfTwo(8));
+ assertEquals(128, roundToPowerOfTwo(128));
+ assertEquals(256, roundToPowerOfTwo(129));
+ assertEquals(256, roundToPowerOfTwo(200));
+ assertEquals(256, roundToPowerOfTwo(255));
+ assertEquals(256, roundToPowerOfTwo(256));
+ assertEquals(0x2000_0000, roundToPowerOfTwo(0x2000_0000));
+ assertEquals(0x4000_0000, roundToPowerOfTwo(0x2000_0001));
+ assertEquals(0x4000_0000, roundToPowerOfTwo(0x3FFF_FFFF));
+ assertEquals(0x4000_0000, roundToPowerOfTwo(0x4000_0000));
+ }
+
+ @Test
public void testOrderedCommutative() {
final int ab = multiHashOrdered(multiHashOrdered(1234, 65537, 13), 16633, 5342);
final int ba = multiHashOrdered(multiHashOrdered(1234, 16633, 5342), 65537, 13);
View it on GitLab: https://salsa.debian.org/java-team/wildfly-common/compare/b0d17c0d1475320def5d4b0edecd7d8cd5b9f553...39597b3bbadc0fea2e53e48ace4df65777da0a94
---
View it on GitLab: https://salsa.debian.org/java-team/wildfly-common/compare/b0d17c0d1475320def5d4b0edecd7d8cd5b9f553...39597b3bbadc0fea2e53e48ace4df65777da0a94
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/pkg-java-commits/attachments/20180515/9a5e9579/attachment.html>
More information about the pkg-java-commits
mailing list