def apply[T]()

in parquet/src/main/scala/magnolify/parquet/ParquetType.scala [120:149]

• 26 lines of code
• 3 McCabe index (conditional complexity)

  def apply[T](
    properties: MagnolifyParquetProperties
  )(implicit f: ParquetField[T], pa: ParquetArray): ParquetType[T] =
    ParquetType[T](CaseMapper.identity, properties)(f, pa)

  def apply[T](
    cm: CaseMapper,
    props: MagnolifyParquetProperties
  )(implicit f: ParquetField[T], pa: ParquetArray): ParquetType[T] = f match {
    case r: ParquetField.Record[_] =>
      new ParquetType[T] {
        @transient override def schema: MessageType =
          Schema.message(r.schema(cm, properties))

        @transient override def avroSchema: AvroSchema = {
          val s = new AvroSchemaConverter().convert(schema)
          // add doc to avro schema
          val fieldDocs = f.fieldDocs(cm)
          SchemaUtil.deepCopy(s, f.typeDoc, fieldDocs.get)
        }

        override private[parquet] def properties: MagnolifyParquetProperties = props
        override def write(c: RecordConsumer, v: T): Unit =
          r.write(c, v)(cm, properties)
        override private[parquet] def newConverter(writerSchema: Type): TypeConverter[T] =
          r.newConverter(writerSchema)
      }
    case _ =>
      throw new IllegalArgumentException(s"ParquetType can only be created from Record. Got $f")
  }