Box Parquet Schema/Reader for List to avoid infinite types. Hopefully…

… can revert in future

amadeus-parquet/src/internal/record/impls.rs

@@ -523,12 +523,13 @@ fn parse_list<T: ParquetData>(
 	Err(ParquetError::General(String::from("Couldn't parse Vec<T>")))
 }
 
+// TODO: remove boxing of schema & reader
 impl<T: Data> ParquetData for List<T>
 where
 	T: ParquetData,
 {
-	default type Schema = ListSchema<T::Schema>;
-	default type Reader = RepeatedReader<T::Reader>;
+	default type Schema = ListSchema<Box<T::Schema>>;
+	default type Reader = RepeatedReader<Box<T::Reader>>;
 	type Predicate = T::Predicate;
 
 	default fn parse(
@@ -545,10 +546,10 @@ where
 		if repetition == Some(Repetition::Repeated) {
 			return Ok((
 				schema.name().to_owned(),
-				type_coerce(ListSchema(
+				type_coerce(Box::new(ListSchema(
 					T::parse(&schema, predicate, Some(Repetition::Required))?.1,
 					ListSchemaType::Repeated,
-				)),
+				))),
 			));
 		}
 		Err(ParquetError::General(String::from("Couldn't parse Vec<T>")))
@@ -559,9 +560,9 @@ where
 		paths: &mut HashMap<ColumnPath, ColumnReader>, batch_size: usize,
 	) -> Self::Reader {
 		let schema: &ListSchema<T::Schema> = type_coerce(schema);
-		type_coerce(list_reader::<T>(
+		type_coerce(Box::new(list_reader::<T>(
 			schema, path, def_level, rep_level, paths, batch_size,
-		))
+		)))
 	}
 }
 

amadeus-parquet/src/internal/record/mod.rs

@@ -178,6 +178,17 @@ pub trait Schema: Debug {
 	) -> fmt::Result;
 }
 
+impl<T: ?Sized> Schema for Box<T>
+where
+	T: Schema,
+{
+	fn fmt(
+		self_: Option<&Self>, r: Option<Repetition>, name: Option<&str>, f: &mut fmt::Formatter,
+	) -> fmt::Result {
+		<T as Schema>::fmt(self_.map(|self_| &**self_), r, name, f)
+	}
+}
+
 /// This trait is implemented by Readers so the values of one or more columns can be read
 /// while taking into account the definition and repetition levels for optional and
 /// repeated values.
@@ -197,3 +208,26 @@ pub trait Reader {
 	/// Get the current repetition level.
 	fn current_rep_level(&self) -> i16;
 }
+
+impl<T: ?Sized> Reader for Box<T>
+where
+	T: Reader,
+{
+	type Item = T::Item;
+
+	fn read(&mut self, def_level: i16, rep_level: i16) -> Result<Self::Item> {
+		(&mut **self).read(def_level, rep_level)
+	}
+	fn advance_columns(&mut self) -> Result<()> {
+		(&mut **self).advance_columns()
+	}
+	fn has_next(&self) -> bool {
+		(&**self).has_next()
+	}
+	fn current_def_level(&self) -> i16 {
+		(&**self).current_def_level()
+	}
+	fn current_rep_level(&self) -> i16 {
+		(&**self).current_rep_level()
+	}
+}