public static boolean equals()

in cassandra-analytics-common/src/main/java/org/apache/cassandra/spark/utils/ComparisonUtils.java [129:202]
70 lines of code
23 McCabe index (conditional complexity)

    public static boolean equals(Object first, Object second)
    {
        if (first instanceof UUID && second instanceof String)  // Spark does not support UUID. We compare the string values.
        {
            return first.toString().equals(second);
        }
        else if (first instanceof ByteBuffer && second instanceof byte[])
        {
            return Arrays.equals(ByteBufferUtils.getArray((ByteBuffer) first), (byte[]) second);
        }
        else if (first instanceof InetAddress && second instanceof byte[])
        {
            return Arrays.equals(((InetAddress) first).getAddress(), (byte[]) second);
        }
        else if (first instanceof BigInteger && second instanceof BigDecimal)
        {
            // Compare the string values
            return first.toString().equals(second.toString());
        }
        else if (first instanceof Integer && second instanceof Date)
        {
            return first.equals((int) ((Date) second).toLocalDate().toEpochDay());
        }

        if (Objects.equals(first, second))
        {
            return true;
        }

        if (first instanceof BigDecimal && second instanceof BigDecimal)
        {
            return ((BigDecimal) first).compareTo((BigDecimal) second) == 0;
        }
        else if (first instanceof Collection && second instanceof Collection)
        {
            Object[] firstArray = ((Collection<Object>) first).toArray();
            Arrays.sort(firstArray, NESTED_COMPARATOR);
            Object[] secondArray = ((Collection<Object>) second).toArray();
            Arrays.sort(secondArray, NESTED_COMPARATOR);
            return equals(firstArray, secondArray);
        }
        else if (first instanceof Map && second instanceof Map)
        {
            Object[] firstKeys = ((Map<Object, Object>) first).keySet().toArray();
            Object[] secondKeys = ((Map<Object, Object>) second).keySet().toArray();
            if (firstKeys[0] instanceof Comparable)
            {
                Arrays.sort(firstKeys);
                Arrays.sort(secondKeys);
            }
            else if (firstKeys[0] instanceof Inet4Address)  // Inet4Address is not Comparable so do byte ordering
            {
                Arrays.sort(firstKeys, INET_COMPARATOR);
                Arrays.sort(secondKeys, INET_COMPARATOR);
            }
            if (equals(firstKeys, secondKeys))
            {
                Object[] firstValues = new Object[firstKeys.length];
                Object[] secondValues = new Object[secondKeys.length];
                IntStream.range(0, firstKeys.length).forEach(position -> {
                    firstValues[position] = ((Map<Object, Object>) first).get(firstKeys[position]);
                    secondValues[position] = ((Map<Object, Object>) second).get(secondKeys[position]);
                });
                return equals(firstValues, secondValues);
            }
            return false;
        }
        else if (first instanceof Object[] && second instanceof Object[])
        {
            return equals((Object[]) first, (Object[]) second);
        }

        return false;
    }