CPD Results
The following document contains the results of PMD's CPD 6.29.0.
Duplications
File |
Line |
org/apache/commons/lang3/builder/CompareToBuilder.java |
440 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
666 |
if (lhs instanceof long[]) {
append((long[]) lhs, (long[]) rhs);
} else if (lhs instanceof int[]) {
append((int[]) lhs, (int[]) rhs);
} else if (lhs instanceof short[]) {
append((short[]) lhs, (short[]) rhs);
} else if (lhs instanceof char[]) {
append((char[]) lhs, (char[]) rhs);
} else if (lhs instanceof byte[]) {
append((byte[]) lhs, (byte[]) rhs);
} else if (lhs instanceof double[]) {
append((double[]) lhs, (double[]) rhs);
} else if (lhs instanceof float[]) {
append((float[]) lhs, (float[]) rhs);
} else if (lhs instanceof boolean[]) {
append((boolean[]) lhs, (boolean[]) rhs);
} else {
// not an array of primitives
// throws a ClassCastException if rhs is not an array
append((Object[]) lhs, (Object[]) rhs, comparator); |
File |
Line |
org/apache/commons/lang3/ArrayUtils.java |
6960 |
org/apache/commons/lang3/ArrayUtils.java |
7039 |
org/apache/commons/lang3/ArrayUtils.java |
7118 |
org/apache/commons/lang3/ArrayUtils.java |
7197 |
org/apache/commons/lang3/ArrayUtils.java |
7276 |
org/apache/commons/lang3/ArrayUtils.java |
7355 |
org/apache/commons/lang3/ArrayUtils.java |
7434 |
org/apache/commons/lang3/ArrayUtils.java |
7515 |
public static void shift(final boolean[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
if (array == null) {
return;
}
if (startIndexInclusive >= array.length - 1 || endIndexExclusive <= 0) {
return;
}
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive >= array.length) {
endIndexExclusive = array.length;
}
int n = endIndexExclusive - startIndexInclusive;
if (n <= 1) {
return;
}
offset %= n;
if (offset < 0) {
offset += n;
}
// For algorithm explanations and proof of O(n) time complexity and O(1) space complexity
// see https://beradrian.wordpress.com/2015/04/07/shift-an-array-in-on-in-place/
while (n > 1 && offset > 0) {
final int n_offset = n - offset;
if (offset > n_offset) {
swap(array, startIndexInclusive, startIndexInclusive + n - n_offset, n_offset);
n = offset;
offset -= n_offset;
} else if (offset < n_offset) {
swap(array, startIndexInclusive, startIndexInclusive + n_offset, offset);
startIndexInclusive += offset;
n = n_offset;
} else {
swap(array, startIndexInclusive, startIndexInclusive + n_offset, offset);
break;
}
}
}
/**
* Shifts the order of the given byte array.
*
* <p>There is no special handling for multi-dimensional arrays. This method
* does nothing for {@code null} or empty input arrays.</p>
*
* @param array the array to shift, may be {@code null}
* @param offset
* The number of positions to rotate the elements. If the offset is larger than the number of elements to
* rotate, than the effective offset is modulo the number of elements to rotate.
* @since 3.5
*/
public static void shift(final byte[] array, final int offset) { |
File |
Line |
org/apache/commons/lang3/ArrayUtils.java |
6960 |
org/apache/commons/lang3/ArrayUtils.java |
7039 |
org/apache/commons/lang3/ArrayUtils.java |
7118 |
org/apache/commons/lang3/ArrayUtils.java |
7197 |
org/apache/commons/lang3/ArrayUtils.java |
7276 |
org/apache/commons/lang3/ArrayUtils.java |
7355 |
org/apache/commons/lang3/ArrayUtils.java |
7434 |
org/apache/commons/lang3/ArrayUtils.java |
7515 |
org/apache/commons/lang3/ArrayUtils.java |
7594 |
public static void shift(final boolean[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
if (array == null) {
return;
}
if (startIndexInclusive >= array.length - 1 || endIndexExclusive <= 0) {
return;
}
if (startIndexInclusive < 0) {
startIndexInclusive = 0;
}
if (endIndexExclusive >= array.length) {
endIndexExclusive = array.length;
}
int n = endIndexExclusive - startIndexInclusive;
if (n <= 1) {
return;
}
offset %= n;
if (offset < 0) {
offset += n;
}
// For algorithm explanations and proof of O(n) time complexity and O(1) space complexity
// see https://beradrian.wordpress.com/2015/04/07/shift-an-array-in-on-in-place/
while (n > 1 && offset > 0) {
final int n_offset = n - offset;
if (offset > n_offset) {
swap(array, startIndexInclusive, startIndexInclusive + n - n_offset, n_offset);
n = offset;
offset -= n_offset;
} else if (offset < n_offset) {
swap(array, startIndexInclusive, startIndexInclusive + n_offset, offset);
startIndexInclusive += offset;
n = n_offset;
} else {
swap(array, startIndexInclusive, startIndexInclusive + n_offset, offset);
break;
}
}
}
/**
* Shifts the order of the given byte array.
*
* <p>There is no special handling for multi-dimensional arrays. This method
* does nothing for {@code null} or empty input arrays.</p>
*
* @param array the array to shift, may be {@code null}
* @param offset
* The number of positions to rotate the elements. If the offset is larger than the number of elements to
* rotate, than the effective offset is modulo the number of elements to rotate.
* @since 3.5
*/
public static void shift(final byte[] array, final int offset) { |
File |
Line |
org/apache/commons/lang3/Functions.java |
635 |
org/apache/commons/lang3/function/Failable.java |
520 |
actualErrorHandler = Functions::rethrow;
} else {
actualErrorHandler = errorHandler;
}
if (resources != null) {
for (final FailableRunnable<? extends Throwable> failableRunnable : resources) {
Objects.requireNonNull(failableRunnable, "runnable");
}
}
Throwable th = null;
try {
action.run();
} catch (final Throwable t) {
th = t;
}
if (resources != null) {
for (final FailableRunnable<?> runnable : resources) {
try {
runnable.run();
} catch (final Throwable t) {
if (th == null) {
th = t;
}
}
}
}
if (th != null) {
try {
actualErrorHandler.accept(th);
} catch (final Throwable t) {
throw rethrow(t);
}
}
}
/**
* A simple try-with-resources implementation, that can be used, if your objects do not implement the
* {@link AutoCloseable} interface. The method executes the {@code action}. The method guarantees, that <em>all</em>
* the {@code resources} are being executed, in the given order, afterwards, and regardless of success, or failure.
* If either the original action, or any of the resource action fails, then the <em>first</em> failure (AKA
* {@link Throwable} is rethrown. Example use:
*
* <pre>
* {@code
* final FileInputStream fis = new FileInputStream("my.file");
* Functions.tryWithResources(useInputStream(fis), () -> fis.close());
* }</pre>
*
* @param action The action to execute. This object <em>will</em> always be invoked.
* @param resources The resource actions to execute. <em>All</em> resource actions will be invoked, in the given
* order. A resource action is an instance of {@link FailableRunnable}, which will be executed.
* @see #tryWithResources(FailableRunnable, FailableConsumer, FailableRunnable...)
*/
@SafeVarargs
public static void tryWithResources(final FailableRunnable<? extends Throwable> action,
final FailableRunnable<? extends Throwable>... resources) {
tryWithResources(action, null, resources);
} |
File |
Line |
org/apache/commons/lang3/exception/ContextedException.java |
189 |
org/apache/commons/lang3/exception/ContextedRuntimeException.java |
189 |
public ContextedException setContextValue(final String label, final Object value) {
exceptionContext.setContextValue(label, value);
return this;
}
/**
* {@inheritDoc}
*/
@Override
public List<Object> getContextValues(final String label) {
return this.exceptionContext.getContextValues(label);
}
/**
* {@inheritDoc}
*/
@Override
public Object getFirstContextValue(final String label) {
return this.exceptionContext.getFirstContextValue(label);
}
/**
* {@inheritDoc}
*/
@Override
public List<Pair<String, Object>> getContextEntries() {
return this.exceptionContext.getContextEntries();
}
/**
* {@inheritDoc}
*/
@Override
public Set<String> getContextLabels() {
return exceptionContext.getContextLabels();
}
/**
* Provides the message explaining the exception, including the contextual data.
*
* @see java.lang.Throwable#getMessage()
* @return the message, never null
*/
@Override
public String getMessage() {
return getFormattedExceptionMessage(super.getMessage());
}
/**
* Provides the message explaining the exception without the contextual data.
*
* @see java.lang.Throwable#getMessage()
* @return the message
* @since 3.0.1
*/
public String getRawMessage() {
return super.getMessage();
}
/**
* {@inheritDoc}
*/
@Override
public String getFormattedExceptionMessage(final String baseMessage) {
return exceptionContext.getFormattedExceptionMessage(baseMessage);
}
} |
File |
Line |
org/apache/commons/lang3/builder/CompareToBuilder.java |
697 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
737 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
777 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
817 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
857 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
897 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
937 |
public CompareToBuilder append(final long[] lhs, final long[] rhs) {
if (comparison != 0) {
return this;
}
if (lhs == rhs) {
return this;
}
if (lhs == null) {
comparison = -1;
return this;
}
if (rhs == null) {
comparison = 1;
return this;
}
if (lhs.length != rhs.length) {
comparison = lhs.length < rhs.length ? -1 : 1;
return this;
}
for (int i = 0; i < lhs.length && comparison == 0; i++) {
append(lhs[i], rhs[i]);
}
return this;
}
/**
* <p>Appends to the {@code builder} the deep comparison of
* two {@code int} arrays.</p>
*
* <ol>
* <li>Check if arrays are the same using {@code ==}</li>
* <li>Check if for {@code null}, {@code null} is less than non-{@code null}</li>
* <li>Check array length, a shorter length array is less than a longer length array</li>
* <li>Check array contents element by element using {@link #append(int, int)}</li>
* </ol>
*
* @param lhs left-hand array
* @param rhs right-hand array
* @return this - used to chain append calls
*/
public CompareToBuilder append(final int[] lhs, final int[] rhs) { |
File |
Line |
org/apache/commons/lang3/text/StrBuilder.java |
607 |
org/apache/commons/lang3/text/StrBuilder.java |
725 |
org/apache/commons/lang3/text/StrBuilder.java |
776 |
org/apache/commons/lang3/text/StrBuilder.java |
825 |
public StrBuilder append(final String str, final int startIndex, final int length) {
if (str == null) {
return appendNull();
}
if (startIndex < 0 || startIndex > str.length()) {
throw new StringIndexOutOfBoundsException("startIndex must be valid");
}
if (length < 0 || (startIndex + length) > str.length()) {
throw new StringIndexOutOfBoundsException("length must be valid");
}
if (length > 0) {
final int len = length();
ensureCapacity(len + length);
str.getChars(startIndex, startIndex + length, buffer, len);
size += length;
}
return this;
}
/**
* Calls {@link String#format(String, Object...)} and appends the result.
*
* @param format the format string
* @param objs the objects to use in the format string
* @return {@code this} to enable chaining
* @see String#format(String, Object...)
* @since 3.2
*/
public StrBuilder append(final String format, final Object... objs) { |
File |
Line |
org/apache/commons/lang3/builder/CompareToBuilder.java |
697 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
737 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
777 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
817 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
857 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
897 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
937 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
977 |
public CompareToBuilder append(final long[] lhs, final long[] rhs) {
if (comparison != 0) {
return this;
}
if (lhs == rhs) {
return this;
}
if (lhs == null) {
comparison = -1;
return this;
}
if (rhs == null) {
comparison = 1;
return this;
}
if (lhs.length != rhs.length) {
comparison = lhs.length < rhs.length ? -1 : 1;
return this;
}
for (int i = 0; i < lhs.length && comparison == 0; i++) {
append(lhs[i], rhs[i]);
}
return this;
}
/**
* <p>Appends to the {@code builder} the deep comparison of
* two {@code int} arrays.</p>
*
* <ol>
* <li>Check if arrays are the same using {@code ==}</li>
* <li>Check if for {@code null}, {@code null} is less than non-{@code null}</li>
* <li>Check array length, a shorter length array is less than a longer length array</li>
* <li>Check array contents element by element using {@link #append(int, int)}</li>
* </ol>
*
* @param lhs left-hand array
* @param rhs right-hand array
* @return this - used to chain append calls
*/
public CompareToBuilder append(final int[] lhs, final int[] rhs) { |
File |
Line |
org/apache/commons/lang3/builder/CompareToBuilder.java |
657 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
697 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
737 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
777 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
817 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
857 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
897 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
937 |
org/apache/commons/lang3/builder/CompareToBuilder.java |
977 |
public CompareToBuilder append(final Object[] lhs, final Object[] rhs, final Comparator<?> comparator) {
if (comparison != 0) {
return this;
}
if (lhs == rhs) {
return this;
}
if (lhs == null) {
comparison = -1;
return this;
}
if (rhs == null) {
comparison = 1;
return this;
}
if (lhs.length != rhs.length) {
comparison = lhs.length < rhs.length ? -1 : 1;
return this;
}
for (int i = 0; i < lhs.length && comparison == 0; i++) {
append(lhs[i], rhs[i], comparator); |
File |
Line |
org/apache/commons/lang3/ArrayUtils.java |
8287 |
org/apache/commons/lang3/ArrayUtils.java |
8358 |
org/apache/commons/lang3/ArrayUtils.java |
8428 |
org/apache/commons/lang3/ArrayUtils.java |
8498 |
org/apache/commons/lang3/ArrayUtils.java |
8568 |
org/apache/commons/lang3/ArrayUtils.java |
8639 |
org/apache/commons/lang3/ArrayUtils.java |
8710 |
org/apache/commons/lang3/ArrayUtils.java |
8782 |
public static void swap(final boolean[] array, int offset1, int offset2, int len) {
if (isEmpty(array) || offset1 >= array.length || offset2 >= array.length) {
return;
}
if (offset1 < 0) {
offset1 = 0;
}
if (offset2 < 0) {
offset2 = 0;
}
len = Math.min(Math.min(len, array.length - offset1), array.length - offset2);
for (int i = 0; i < len; i++, offset1++, offset2++) {
final boolean aux = array[offset1]; |
File |
Line |
org/apache/commons/lang3/builder/EqualsBuilder.java |
835 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
866 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
897 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
928 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
959 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
990 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
1021 |
org/apache/commons/lang3/builder/EqualsBuilder.java |
1052 |
public EqualsBuilder append(final Object[] lhs, final Object[] rhs) {
if (!isEquals) {
return this;
}
if (lhs == rhs) {
return this;
}
if (lhs == null || rhs == null) {
this.setEquals(false);
return this;
}
if (lhs.length != rhs.length) {
this.setEquals(false);
return this;
}
for (int i = 0; i < lhs.length && isEquals; ++i) {
append(lhs[i], rhs[i]);
}
return this;
}
/**
* <p>Deep comparison of array of {@code long}. Length and all
* values are compared.</p>
*
* <p>The method {@link #append(long, long)} is used.</p>
*
* @param lhs the left hand {@code long[]}
* @param rhs the right hand {@code long[]}
* @return EqualsBuilder - used to chain calls.
*/
public EqualsBuilder append(final long[] lhs, final long[] rhs) { |
File |
Line |
org/apache/commons/lang3/Conversion.java |
1290 |
org/apache/commons/lang3/Conversion.java |
1329 |
throw new IllegalArgumentException("(nHexs-1)*4+srcPos is greater or equal to than 32");
}
final StringBuilder sb = new StringBuilder(dstInit);
int append = sb.length();
for (int i = 0; i < nHexs; i++) {
final int shift = i * 4 + srcPos;
final int bits = 0xF & (src >> shift);
if (dstPos + i == append) {
++append;
sb.append(intToHexDigit(bits));
} else {
sb.setCharAt(dstPos + i, intToHexDigit(bits));
}
}
return sb.toString();
}
/**
* <p>
* Converts a short into an array of Char using the default (little endian, Lsb0) byte and
* bit ordering.
* </p>
*
* @param src the short to convert
* @param srcPos the position in {@code src}, in bits, from where to start the conversion
* @param dstInit the initial value for the result String
* @param dstPos the position in {@code dst} where to copy the result
* @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the
* width of the input (from srcPos to msb)
* @return {@code dst}
* @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 16}
* @throws StringIndexOutOfBoundsException if {@code dst.init.length() < dstPos}
*/
public static String shortToHex(final short src, final int srcPos, final String dstInit, final int dstPos, |
File |
Line |
org/apache/commons/lang3/Conversion.java |
1290 |
org/apache/commons/lang3/Conversion.java |
1329 |
org/apache/commons/lang3/Conversion.java |
1368 |
throw new IllegalArgumentException("(nHexs-1)*4+srcPos is greater or equal to than 32");
}
final StringBuilder sb = new StringBuilder(dstInit);
int append = sb.length();
for (int i = 0; i < nHexs; i++) {
final int shift = i * 4 + srcPos;
final int bits = 0xF & (src >> shift);
if (dstPos + i == append) {
++append;
sb.append(intToHexDigit(bits));
} else {
sb.setCharAt(dstPos + i, intToHexDigit(bits));
}
}
return sb.toString();
}
/**
* <p>
* Converts a short into an array of Char using the default (little endian, Lsb0) byte and
* bit ordering.
* </p>
*
* @param src the short to convert
* @param srcPos the position in {@code src}, in bits, from where to start the conversion
* @param dstInit the initial value for the result String
* @param dstPos the position in {@code dst} where to copy the result
* @param nHexs the number of Chars to copy to {@code dst}, must be smaller or equal to the
* width of the input (from srcPos to msb)
* @return {@code dst}
* @throws IllegalArgumentException if {@code (nHexs-1)*4+srcPos >= 16}
* @throws StringIndexOutOfBoundsException if {@code dst.init.length() < dstPos}
*/
public static String shortToHex(final short src, final int srcPos, final String dstInit, final int dstPos, |
|