Method parse_enum

avro/src/schema/parser.rs:614–688

Parse a `serde_json::Value` representing a Avro enum type into a `Schema`.

(
        &mut self,
        complex: &Map<String, Value>,
        enclosing_namespace: NamespaceRef,
    )

        let fully_qualified_name = Name::parse(&mut complex, enclosing_namespace)?;
        let aliases =
            self.fix_aliases_namespace(complex.aliases()?, fully_qualified_name.namespace())?;

        let symbols = match symbols_opt {
            Some(Value::Array(array)) => array
                .into_iter()
                .map(|v| match v {
                    Value::String(s) => Ok(s),
                    _ => Err(Error::new(Details::GetEnumSymbolsFieldArrayInvalidType(
                        v.description(),
                    ))),
                })
                .collect::<Result<Vec<_>, _>>(),
            Some(value) => Err(Details::GetEnumSymbolsFieldInvalidType(value.description()).into()),
            None => Err(Details::GetEnumSymbolsField.into()),
        }?;

        let mut existing_symbols: HashSet<&String> = HashSet::with_capacity(symbols.len());
        for symbol in symbols.iter() {
            validate_enum_symbol_name(symbol)?;

            // Ensure there are no duplicate symbols
            if existing_symbols.contains(&symbol) {
                return Err(Details::EnumSymbolDuplicate(symbol.to_string()).into());
            }

            existing_symbols.insert(symbol);
        }

        let default = match complex.remove("default") {
            Some(Value::String(s)) => {
                if !symbols.contains(&s) {
                    return Err(Details::GetEnumDefault { symbol: s, symbols }.into());
                }
                Some(s)
            }
            Some(v) => return Err(Details::EnumDefaultWrongType(v).into()),
            None => None,
        };

        let schema = Schema::Enum(EnumSchema {
            name: fully_qualified_name.clone(),
            aliases: aliases.clone(),
            doc: complex.doc()?,
            symbols,
            default,
            attributes: self.get_custom_attributes(complex),
        });

        self.register_parsed_schema(&fully_qualified_name, &schema, &aliases);

        Ok(schema)
    }

    /// Parse a `serde_json::Value` representing a Avro array type into a `Schema`.
    fn parse_array(
        &mut self,
        mut complex: Map<String, Value>,