private DataType parse()

in core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeCqlNameParser.java [57:154]
85 lines of code
20 McCabe index (conditional complexity)

  private DataType parse(
      String toParse,
      CqlIdentifier keyspaceId,
      boolean frozen,
      Map<CqlIdentifier, UserDefinedType> userTypes,
      InternalDriverContext context) {

    if (toParse.startsWith("'")) {
      return DataTypes.custom(toParse.substring(1, toParse.length() - 1));
    }

    Parser parser = new Parser(toParse, 0);
    String type = parser.parseTypeName();

    if (type.equalsIgnoreCase(RawColumn.THRIFT_EMPTY_TYPE)) {
      return DataTypes.custom(type);
    }

    DataType nativeType = NATIVE_TYPES_BY_NAME.get(type.toLowerCase(Locale.ROOT));
    if (nativeType != null) {
      return nativeType;
    }

    if (parser.isEOS()) {
      // No parameters => it's a UDT
      CqlIdentifier name = CqlIdentifier.fromCql(type);
      if (userTypes != null) {
        UserDefinedType userType = userTypes.get(name);
        if (userType == null) {
          throw new IllegalStateException(
              String.format("Can't find referenced user type %s", type));
        }
        return userType.copy(frozen);
      } else {
        return new ShallowUserDefinedType(keyspaceId, name, frozen);
      }
    }

    List<String> parameters = parser.parseTypeParameters();
    if (type.equalsIgnoreCase("list")) {
      if (parameters.size() != 1) {
        throw new IllegalArgumentException(
            String.format("Expecting single parameter for list, got %s", parameters));
      }
      DataType elementType = parse(parameters.get(0), keyspaceId, false, userTypes, context);
      return DataTypes.listOf(elementType, frozen);
    }

    if (type.equalsIgnoreCase("set")) {
      if (parameters.size() != 1) {
        throw new IllegalArgumentException(
            String.format("Expecting single parameter for set, got %s", parameters));
      }
      DataType elementType = parse(parameters.get(0), keyspaceId, false, userTypes, context);
      return DataTypes.setOf(elementType, frozen);
    }

    if (type.equalsIgnoreCase("map")) {
      if (parameters.size() != 2) {
        throw new IllegalArgumentException(
            String.format("Expecting two parameters for map, got %s", parameters));
      }
      DataType keyType = parse(parameters.get(0), keyspaceId, false, userTypes, context);
      DataType valueType = parse(parameters.get(1), keyspaceId, false, userTypes, context);
      return DataTypes.mapOf(keyType, valueType, frozen);
    }

    if (type.equalsIgnoreCase("frozen")) {
      if (parameters.size() != 1) {
        throw new IllegalArgumentException(
            String.format("Expecting single parameter for frozen keyword, got %s", parameters));
      }
      return parse(parameters.get(0), keyspaceId, true, userTypes, context);
    }

    if (type.equalsIgnoreCase("tuple")) {
      if (parameters.isEmpty()) {
        throw new IllegalArgumentException("Expecting at list one parameter for tuple, got none");
      }
      ImmutableList.Builder<DataType> componentTypesBuilder = ImmutableList.builder();
      for (String rawType : parameters) {
        componentTypesBuilder.add(parse(rawType, keyspaceId, false, userTypes, context));
      }
      return new DefaultTupleType(componentTypesBuilder.build(), context);
    }

    if (type.equalsIgnoreCase("vector")) {
      if (parameters.size() != 2) {
        throw new IllegalArgumentException(
            String.format("Expecting two parameters for vector custom type, got %s", parameters));
      }
      DataType subType = parse(parameters.get(0), keyspaceId, false, userTypes, context);
      int dimensions = Integer.parseInt(parameters.get(1));
      return new DefaultVectorType(subType, dimensions);
    }

    throw new IllegalArgumentException("Could not parse type name " + toParse);
  }