private static Converter newConverter()

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

  private static Converter newConverter(Schema schema, Type type,
      GenericData model, Class<?> knownClass, ParentValueContainer setter) {
    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);
    case RECORD:
      return new AvroRecordConverter(parent, type.asGroupType(), schema, model);
    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);
      }
      return new AvroCollectionConverter(parent, type.asGroupType(), schema,
          model, arrayDatumClass);
    case MAP:
      return new MapConverter(parent, type.asGroupType(), schema, model);
    case UNION:
      return new AvroUnionConverter(parent, type, schema, model);
    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));
    }
  }