[avro] 01/02: AVRO-3683: WIP compiles

[mg...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

mgrigorov pushed a commit to branch avro-3683-multiple-schemas
in repository https://gitbox.apache.org/repos/asf/avro.git

commit 2aebeab25ec9028a7c9d257debaa620b868b7942
Author: Martin Tzvetanov Grigorov <mg...@apache.org>
AuthorDate: Thu Dec 15 01:00:31 2022 +0200

    AVRO-3683: WIP compiles
    
    Signed-off-by: Martin Tzvetanov Grigorov <mg...@apache.org>
---
 lang/rust/avro/src/schema.rs | 32 ++++++++++++++++----------------
 lang/rust/avro/src/writer.rs |  5 +++--
 2 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/lang/rust/avro/src/schema.rs b/lang/rust/avro/src/schema.rs
index 5784f1901..1ffb9e6ea 100644
--- a/lang/rust/avro/src/schema.rs
+++ b/lang/rust/avro/src/schema.rs
@@ -401,7 +401,7 @@ impl Serialize for Alias {
 
 pub(crate) struct ResolvedSchema<'s> {
     names_ref: NamesRef<'s>,
-    schemata: &'s [&'s Schema],
+    schemata: Vec<&'s Schema>,
 }
 
 impl<'s> TryFrom<&'s Schema> for ResolvedSchema<'s> {
@@ -411,9 +411,9 @@ impl<'s> TryFrom<&'s Schema> for ResolvedSchema<'s> {
         let names = HashMap::new();
         let mut rs = ResolvedSchema {
             names_ref: names,
-            schemata: &[schema],
+            schemata: vec![schema],
         };
-        Self::from_internal(rs.schemata, &mut rs.names_ref, &None)?;
+        Self::from_internal(rs.get_schemata(), &mut rs.names_ref, &None)?;
         Ok(rs)
     }
 }
@@ -425,34 +425,35 @@ impl<'s> TryFrom<&'s [&'s Schema]> for ResolvedSchema<'s> {
         let names = HashMap::new();
         let mut rs = ResolvedSchema {
             names_ref: names,
-            schemata,
+            schemata: schemata.to_vec(),
         };
-        Self::from_internal(rs.schemata, &mut rs.names_ref, &None)?;
+        Self::from_internal(rs.get_schemata(), &mut rs.names_ref, &None)?;
         Ok(rs)
     }
 }
 
 impl<'s> ResolvedSchema<'s> {
-    pub(crate) fn get_schemata(&self) -> &'s [&'s Schema] {
-        self.schemata
+    pub(crate) fn get_schemata(&self) -> Vec<&'s Schema> {
+        self.schemata.clone()
     }
+
     pub(crate) fn get_names(&self) -> &NamesRef<'s> {
         &self.names_ref
     }
 
     fn from_internal(
-        schemata: &'s [&'s Schema],
+        schemata: Vec<&'s Schema>,
         names_ref: &mut NamesRef<'s>,
         enclosing_namespace: &Namespace,
     ) -> AvroResult<()> {
         for schema in schemata {
             match schema {
                 Schema::Array(schema) | Schema::Map(schema) => {
-                    Self::from_internal(&[schema], names_ref, enclosing_namespace)?
+                    Self::from_internal(vec![schema], names_ref, enclosing_namespace)?
                 }
                 Schema::Union(UnionSchema { schemas, .. }) => {
                     for schema in schemas {
-                        Self::from_internal(&[schema], names_ref, enclosing_namespace)?
+                        Self::from_internal(vec![schema], names_ref, enclosing_namespace)?
                     }
                 }
                 Schema::Enum { name, .. } | Schema::Fixed { name, .. } => {
@@ -474,18 +475,17 @@ impl<'s> ResolvedSchema<'s> {
                     } else {
                         let record_namespace = fully_qualified_name.namespace;
                         for field in fields {
-                            Self::from_internal(&[&field.schema], names_ref, &record_namespace)?
+                            Self::from_internal(vec![&field.schema], names_ref, &record_namespace)?
                         }
                     }
                 }
                 Schema::Ref { name } => {
                     let fully_qualified_name = name.fully_qualified_name(enclosing_namespace);
-                    names_ref
-                        .get(&fully_qualified_name)
-                        .map(|_| ())
-                        .ok_or_else(|| return Error::SchemaResolutionError(fully_qualified_name))
+                    if let None = names_ref.get(&fully_qualified_name) {
+                        return Err(Error::SchemaResolutionError(fully_qualified_name));
+                    }
                 }
-                _ => Ok(()),
+                _ => (),
             }
         }
         Ok(())
diff --git a/lang/rust/avro/src/writer.rs b/lang/rust/avro/src/writer.rs
index c777e31cd..6264e07de 100644
--- a/lang/rust/avro/src/writer.rs
+++ b/lang/rust/avro/src/writer.rs
@@ -1285,7 +1285,8 @@ mod tests {
         ]
     }"#;
 
-        let schemata = Schema::parse_list(&[schema_a_str, schema_b_str]).unwrap();
+        let schemata: Vec<Schema> = Schema::parse_list(&[schema_a_str, schema_b_str]).unwrap();
+        let schemata: Vec<&Schema> = schemata.iter().collect();
         let record = Value::Record(vec![(
             "field_b".into(),
             Value::Record(vec![("field_a".into(), Value::Float(1.0))]),
@@ -1293,7 +1294,7 @@ mod tests {
 
         let expected: Vec<u8> = Vec::new();
         assert_eq!(
-            to_avro_datum_schemata(&schemata[..], record).unwrap(),
+            to_avro_datum_schemata(&schemata.as_slice(), record).unwrap(),
             expected
         );
     }