private static Converter newConverter()

in parquet-avro/src/main/java/org/apache/parquet/avro/AvroRecordConverter.java [339:418]
77 lines of code
29 McCabe index (conditional complexity)

  private static Converter newConverter(
      Schema schema,
      Type type,
      GenericData model,
      Class<?> knownClass,
      ParentValueContainer setter,
      ReflectClassValidator validator) {
    LogicalType logicalType = schema.getLogicalType();
    Conversion<?> conversion;

    if (knownClass != null) {
      conversion = model.getConversionByClass(knownClass, logicalType);
    } else {
      conversion = model.getConversionFor(logicalType);
    }

    ParentValueContainer parent = ParentValueContainer.getConversionContainer(setter, conversion, schema);

    switch (schema.getType()) {
      case BOOLEAN:
        return new AvroConverters.FieldBooleanConverter(parent);
      case INT:
        Class<?> intDatumClass = getDatumClass(conversion, knownClass, schema, model);
        if (intDatumClass == null) {
          return new AvroConverters.FieldIntegerConverter(parent);
        }
        if (intDatumClass == byte.class || intDatumClass == Byte.class) {
          return new AvroConverters.FieldByteConverter(parent);
        }
        if (intDatumClass == char.class || intDatumClass == Character.class) {
          return new AvroConverters.FieldCharConverter(parent);
        }
        if (intDatumClass == short.class || intDatumClass == Short.class) {
          return new AvroConverters.FieldShortConverter(parent);
        }
        return new AvroConverters.FieldIntegerConverter(parent);
      case LONG:
        return new AvroConverters.FieldLongConverter(parent);
      case FLOAT:
        return new AvroConverters.FieldFloatConverter(parent);
      case DOUBLE:
        return new AvroConverters.FieldDoubleConverter(parent);
      case BYTES:
        Class<?> byteDatumClass = getDatumClass(conversion, knownClass, schema, model);
        if (byteDatumClass == null) {
          return new AvroConverters.FieldByteBufferConverter(parent);
        }
        if (byteDatumClass.isArray() && byteDatumClass.getComponentType() == byte.class) {
          return new AvroConverters.FieldByteArrayConverter(parent);
        }
        return new AvroConverters.FieldByteBufferConverter(parent);
      case STRING:
        if (logicalType != null
            && logicalType.getName().equals(LogicalTypes.uuid().getName())) {
          return new AvroConverters.FieldUUIDConverter(parent, type.asPrimitiveType());
        }
        return newStringConverter(schema, model, parent, validator);
      case RECORD:
        return new AvroRecordConverter(parent, type.asGroupType(), schema, model, validator);
      case ENUM:
        return new AvroConverters.FieldEnumConverter(parent, schema, model);
      case ARRAY:
        Class<?> arrayDatumClass = getDatumClass(conversion, knownClass, schema, model);
        if (arrayDatumClass != null && arrayDatumClass.isArray()) {
          return new AvroArrayConverter(
              parent, type.asGroupType(), schema, model, arrayDatumClass, validator);
        }
        return new AvroCollectionConverter(
            parent, type.asGroupType(), schema, model, arrayDatumClass, validator);
      case MAP:
        return new MapConverter(parent, type.asGroupType(), schema, model, validator);
      case UNION:
        return new AvroUnionConverter(parent, type, schema, model, validator);
      case FIXED:
        return new AvroConverters.FieldFixedConverter(parent, schema, model);
      default:
        throw new UnsupportedOperationException(
            String.format("Cannot convert Avro type: %s to Parquet type: %s", schema, type));
    }
  }