private DataType parse()

in core/src/main/java/com/datastax/oss/driver/internal/core/metadata/schema/parsing/DataTypeClassNameParser.java [86:177]
77 lines of code
16 McCabe index (conditional complexity)

  private DataType parse(
      String toParse,
      Map<CqlIdentifier, UserDefinedType> userTypes,
      AttachmentPoint attachmentPoint,
      String logPrefix) {
    boolean frozen = false;
    if (isReversed(toParse)) {
      // Just skip the ReversedType part, we don't care
      toParse = getNestedClassName(toParse);
    } else if (toParse.startsWith("org.apache.cassandra.db.marshal.FrozenType")) {
      frozen = true;
      toParse = getNestedClassName(toParse);
    }

    Parser parser = new Parser(toParse, 0);
    String next = parser.parseNextName();

    if (next.startsWith("org.apache.cassandra.db.marshal.ListType")) {
      DataType elementType =
          parse(parser.getTypeParameters().get(0), userTypes, attachmentPoint, logPrefix);
      return DataTypes.listOf(elementType, frozen);
    }

    if (next.startsWith("org.apache.cassandra.db.marshal.SetType")) {
      DataType elementType =
          parse(parser.getTypeParameters().get(0), userTypes, attachmentPoint, logPrefix);
      return DataTypes.setOf(elementType, frozen);
    }

    if (next.startsWith("org.apache.cassandra.db.marshal.MapType")) {
      List<String> parameters = parser.getTypeParameters();
      DataType keyType = parse(parameters.get(0), userTypes, attachmentPoint, logPrefix);
      DataType valueType = parse(parameters.get(1), userTypes, attachmentPoint, logPrefix);
      return DataTypes.mapOf(keyType, valueType, frozen);
    }

    if (frozen)
      LOG.warn(
          "[{}] Got o.a.c.db.marshal.FrozenType for something else than a collection, "
              + "this driver version might be too old for your version of Cassandra",
          logPrefix);

    if (next.startsWith("org.apache.cassandra.db.marshal.UserType")) {
      ++parser.idx; // skipping '('

      CqlIdentifier keyspace = CqlIdentifier.fromInternal(parser.readOne());
      parser.skipBlankAndComma();
      String typeName =
          TypeCodecs.TEXT.decode(
              Bytes.fromHexString("0x" + parser.readOne()), attachmentPoint.getProtocolVersion());
      if (typeName == null) {
        throw new AssertionError("Type name cannot be null, this is a server bug");
      }
      CqlIdentifier typeId = CqlIdentifier.fromInternal(typeName);
      Map<String, String> nameAndTypeParameters = parser.getNameAndTypeParameters();

      // Avoid re-parsing if we already have the definition
      if (userTypes != null && userTypes.containsKey(typeId)) {
        // copy as frozen since C* 2.x UDTs are always frozen.
        return userTypes.get(typeId).copy(true);
      } else {
        UserDefinedTypeBuilder builder = new UserDefinedTypeBuilder(keyspace, typeId);
        parser.skipBlankAndComma();
        for (Map.Entry<String, String> entry : nameAndTypeParameters.entrySet()) {
          CqlIdentifier fieldName = CqlIdentifier.fromInternal(entry.getKey());
          DataType fieldType = parse(entry.getValue(), userTypes, attachmentPoint, logPrefix);
          builder.withField(fieldName, fieldType);
        }
        // Create a frozen UserType since C* 2.x UDTs are always frozen.
        return builder.frozen().withAttachmentPoint(attachmentPoint).build();
      }
    }

    if (next.startsWith("org.apache.cassandra.db.marshal.TupleType")) {
      List<String> rawTypes = parser.getTypeParameters();
      ImmutableList.Builder<DataType> componentTypesBuilder = ImmutableList.builder();
      for (String rawType : rawTypes) {
        componentTypesBuilder.add(parse(rawType, userTypes, attachmentPoint, logPrefix));
      }
      return new DefaultTupleType(componentTypesBuilder.build(), attachmentPoint);
    }

    if (next.startsWith("org.apache.cassandra.db.marshal.VectorType")) {
      Iterator<String> rawTypes = parser.getTypeParameters().iterator();
      DataType subtype = parse(rawTypes.next(), userTypes, attachmentPoint, logPrefix);
      int dimensions = Integer.parseInt(rawTypes.next());
      return DataTypes.vectorOf(subtype, dimensions);
    }

    DataType type = NATIVE_TYPES_BY_CLASS_NAME.get(next);
    return type == null ? DataTypes.custom(toParse) : type;
  }