private static LeafResolver buildLeafResolver()

in server/src/main/java/org/eclipse/jifa/server/support/AnalysisApiArgumentResolverFactory.java [113:159]
46 lines of code
16 McCabe index (conditional complexity)

    private static LeafResolver buildLeafResolver(ApiParameter parameter) {
        Type type = parameter.type();
        String name = parameter.name();
        boolean required = parameter.required();
        boolean targetPath = parameter.targetPath();
        boolean comparisonTargetPath = parameter.comparisonTargetPath();

        return LEAF_RESOLVERS.computeIfAbsent
                                     (parameter,
                                      k -> {
                                          if (type == boolean.class || type == Boolean.class) {
                                              return new BooleanResolver(name, required);
                                          } else if (type == int.class || type == Integer.class) {
                                              return new IntResolver(name, required);
                                          } else if (type == long.class || type == Long.class) {
                                              return new LongResolver(name, required);
                                          } else if (type == double.class || type == DoubleResolver.class) {
                                              return new DoubleResolver(name, required);
                                          } else if (type == String.class) {
                                              return new StringResolver(name, required);
                                          } else if (type == Path.class) {
                                              if (targetPath) {
                                                  return new TargetPathResolver(name);
                                              } else {
                                                  assert comparisonTargetPath;
                                                  return new ComparisonPathResolver(name);
                                              }
                                          } else {
                                              Class<?> raw;
                                              if (type instanceof Class<?> clazz) {
                                                  raw = clazz;
                                              } else if (type instanceof ParameterizedType pt) {
                                                  raw = (Class<?>) pt.getRawType();
                                              } else {
                                                  throw new IllegalArgumentException("Unsupported type: " + type);
                                              }
                                              if (raw.isEnum()) {
                                                  return new EnumResolver(name, required, raw);
                                              } else if (!raw.isPrimitive()) {
                                                  return new ObjectResolver(name, required, type);
                                              } else {
                                                  throw new IllegalArgumentException("Unsupported type: " + type);
                                              }
                                          }
                                      }
                                     );
    }