public static Number increment()

in core/src/main/java/com/jetbrains/youtrackdb/internal/core/metadata/schema/PropertyTypeInternal.java [1780:1968]
183 lines of code
53 McCabe index (conditional complexity)

  public static Number increment(final Number a, final Number b) {
    if (a == null || b == null) {
      throw new IllegalArgumentException("Cannot increment a null value");
    }

    switch (a) {
      case Integer i -> {
        switch (b) {
          case Integer integer -> {
            final var sum = a.intValue() + b.intValue();
            if (sum < 0 && a.intValue() > 0 && b.intValue() > 0)
            // SPECIAL CASE: UPGRADE TO LONG
            {
              return (long) (a.intValue() + b.intValue());
            }
            return sum;
          }
          case Long l -> {
            return a.intValue() + b.longValue();
          }
          case Short aShort -> {
            final var sum = a.intValue() + b.shortValue();
            if (sum < 0 && a.intValue() > 0 && b.shortValue() > 0)
            // SPECIAL CASE: UPGRADE TO LONG
            {
              return (long) (a.intValue() + b.shortValue());
            }
            return sum;
          }
          case Float v -> {
            return a.intValue() + b.floatValue();
          }
          case Double v -> {
            return a.intValue() + b.doubleValue();
          }
          case BigDecimal bigDecimal -> {
            return new BigDecimal(a.intValue()).add(bigDecimal);
          }
          default -> {
          }
        }
      }
      case Long l -> {
        switch (b) {
          case Integer i -> {
            return a.longValue() + b.intValue();
          }
          case Long aLong -> {
            return a.longValue() + b.longValue();
          }
          case Short i -> {
            return a.longValue() + b.shortValue();
          }
          case Float v -> {
            return a.longValue() + b.floatValue();
          }
          case Double v -> {
            return a.longValue() + b.doubleValue();
          }
          case BigDecimal bigDecimal -> {
            return new BigDecimal(a.longValue()).add(bigDecimal);
          }
          default -> {
          }
        }
      }
      case Short i -> {
        switch (b) {
          case Integer integer -> {
            final var sum = a.shortValue() + b.intValue();
            if (sum < 0 && a.shortValue() > 0 && b.intValue() > 0)
            // SPECIAL CASE: UPGRADE TO LONG
            {
              return (long) (a.shortValue() + b.intValue());
            }
            return sum;
          }
          case Long l -> {
            return a.shortValue() + b.longValue();
          }
          case Short aShort -> {
            final var sum = a.shortValue() + b.shortValue();
            if (sum < 0 && a.shortValue() > 0 && b.shortValue() > 0)
            // SPECIAL CASE: UPGRADE TO INTEGER
            {
              return a.intValue() + b.intValue();
            }
            return sum;
          }
          case Float v -> {
            return a.shortValue() + b.floatValue();
          }
          case Double v -> {
            return a.shortValue() + b.doubleValue();
          }
          case BigDecimal bigDecimal -> {
            return new BigDecimal(a.shortValue()).add(bigDecimal);
          }
          default -> {
          }
        }
      }
      case Float v -> {
        switch (b) {
          case Integer i -> {
            return a.floatValue() + b.intValue();
          }
          case Long l -> {
            return a.floatValue() + b.longValue();
          }
          case Short i -> {
            return a.floatValue() + b.shortValue();
          }
          case Float aFloat -> {
            return a.floatValue() + b.floatValue();
          }
          case Double aDouble -> {
            return a.floatValue() + b.doubleValue();
          }
          case BigDecimal bigDecimal -> {
            return BigDecimal.valueOf(a.floatValue()).add(bigDecimal);
          }
          default -> {
          }
        }
      }
      case Double v -> {
        switch (b) {
          case Integer i -> {
            return a.doubleValue() + b.intValue();
          }
          case Long l -> {
            return a.doubleValue() + b.longValue();
          }
          case Short i -> {
            return a.doubleValue() + b.shortValue();
          }
          case Float aFloat -> {
            return a.doubleValue() + b.floatValue();
          }
          case Double aDouble -> {
            return a.doubleValue() + b.doubleValue();
          }
          case BigDecimal bigDecimal -> {
            return BigDecimal.valueOf(a.doubleValue()).add(bigDecimal);
          }
          default -> {
          }
        }
      }
      case BigDecimal bigDecimal -> {
        switch (b) {
          case Integer i -> {
            return ((BigDecimal) a).add(new BigDecimal(b.intValue()));
          }
          case Long l -> {
            return ((BigDecimal) a).add(new BigDecimal(b.longValue()));
          }
          case Short i -> {
            return ((BigDecimal) a).add(new BigDecimal(b.shortValue()));
          }
          case Float v -> {
            return ((BigDecimal) a).add(BigDecimal.valueOf(b.floatValue()));
          }
          case Double v -> {
            return ((BigDecimal) a).add(BigDecimal.valueOf(b.doubleValue()));
          }
          case BigDecimal decimal -> {
            return ((BigDecimal) a).add(decimal);
          }
          default -> {
          }
        }
      }
      default -> {
      }
    }

    throw new IllegalArgumentException(
        "Cannot increment value '"
            + a
            + "' ("
            + a.getClass()
            + ") with '"
            + b
            + "' ("
            + b.getClass()
            + ")");
  }