/// <summary>
/// Parses the specified token.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="parent">The parent schema.</param>
/// <param name="namedSchemas">The schemas.</param>
/// <returns>
/// Schema internal representation.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when JSON schema type is not supported.</exception>
private TypeSchema Parse(JToken token, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
{
if (token.Type == JTokenType.Object)
{
return(this.ParseJsonObject(token as JObject, parent, namedSchemas));
}
if (token.Type == JTokenType.String)
{
var t = (string)token;
if (namedSchemas.ContainsKey(t))
{
return(namedSchemas[t]);
}
if (parent != null && namedSchemas.ContainsKey(parent.Namespace + "." + t))
{
return(namedSchemas[parent.Namespace + "." + t]);
}
// Primitive.
return(this.ParsePrimitiveTypeFromString(t));
}
if (token.Type == JTokenType.Array)
{
return(this.ParseUnionType(token as JArray, parent, namedSchemas));
}
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Unexpected Json schema type '{0}'.", token));
}
/// <summary>
/// Parses the record type.
/// </summary>
/// <param name="record">The record.</param>
/// <param name="parent">The parent schema.</param>
/// <param name="namedSchemas">The named schemas.</param>
/// <returns>
/// Schema internal representation.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when <paramref name="record"/> can not be parsed properly.</exception>
private TypeSchema ParseRecordType(JObject record, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
{
var name = record.RequiredProperty <string>(Token.Name);
var nspace = this.GetNamespace(record, parent, name);
var recordName = new SchemaName(name, nspace);
var doc = record.OptionalProperty <string>(Token.Doc);
var aliases = this.GetAliases(record, recordName.Namespace);
var attributes = new NamedEntityAttributes(recordName, aliases, doc);
Dictionary <string, string> customAttributes = record.GetAttributesNotIn(StandardProperties.Record);
var result = new RecordSchema(attributes, typeof(AvroRecord), customAttributes);
namedSchemas.Add(result.FullName, result);
List <RecordField> fields = record.OptionalArrayProperty(
Token.Fields,
(field, index) =>
{
if (field.Type != JTokenType.Object)
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Property 'fields' has invalid value '{0}'.", field));
}
return(this.ParseRecordField(field as JObject, result, namedSchemas, index));
});
fields.ForEach(result.AddField);
return(result);
}
/// <summary>
/// Parses a JSON object representing an Avro enumeration to a <see cref="EnumSchema"/>.
/// </summary>
/// <param name="enumeration">The JSON token that represents the enumeration.</param>
/// <param name="parent">The parent schema.</param>
/// <param name="namedSchemas">The named schemas.</param>
/// <returns>
/// Instance of <see cref="TypeSchema" /> containing IR of the enumeration.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when <paramref name="enumeration"/> contains invalid symbols.</exception>
private TypeSchema ParseEnumType(JObject enumeration, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
{
var name = enumeration.RequiredProperty <string>(Token.Name);
var nspace = this.GetNamespace(enumeration, parent, name);
var enumName = new SchemaName(name, nspace);
var doc = enumeration.OptionalProperty <string>(Token.Doc);
var aliases = this.GetAliases(enumeration, enumName.Namespace);
var attributes = new NamedEntityAttributes(enumName, aliases, doc);
List <string> symbols = enumeration.OptionalArrayProperty(
Token.Symbols,
(symbol, index) =>
{
if (symbol.Type != JTokenType.String)
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Expected an enum symbol of type string however the type of the symbol is '{0}'.", symbol.Type));
}
return((string)symbol);
});
Dictionary <string, string> customAttributes = enumeration.GetAttributesNotIn(StandardProperties.Enumeration);
var result = new EnumSchema(attributes, typeof(AvroEnum), customAttributes);
namedSchemas.Add(result.FullName, result);
symbols.ForEach(result.AddSymbol);
return(result);
}
/// <summary>
/// Parses a union token.
/// </summary>
/// <param name="unionToken">The union token.</param>
/// <param name="parent">The parent.</param>
/// <param name="namedSchemas">The named schemas.</param>
/// <returns>
/// Schema internal representation.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when union schema type is invalid.</exception>
private TypeSchema ParseUnionType(JArray unionToken, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
{
var types = new HashSet <string>();
var schemas = new List <TypeSchema>();
foreach (var typeAlternative in unionToken.Children())
{
var schema = this.Parse(typeAlternative, parent, namedSchemas);
if (schema.Type == global::AvroConvert.Schema.Schema.Type.Union)
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Union schemas cannot be nested:'{0}'.", unionToken));
}
if (types.Contains(schema.Type.ToString()))
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Unions cannot contains schemas of the same type: '{0}'.", schema.Type));
}
types.Add(schema.Type.ToString());
schemas.Add(schema);
}
return(new UnionSchema(schemas, typeof(object)));
}
private string GetNamespace(JObject type, NamedSchema parentSchema, string name)
{
var nspace = type.OptionalProperty <string>(Token.Namespace);
if (string.IsNullOrEmpty(nspace) && !name.Contains(".") && parentSchema != null)
{
nspace = parentSchema.Namespace;
}
return(nspace);
}
/// <summary>
/// Parses a JSON object representing an Avro map.
/// </summary>
/// <param name="map">JSON representing the map.</param>
/// <param name="parent">The parent.</param>
/// <param name="namedSchemas">The named schemas.</param>
/// <returns>
/// A corresponding schema.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when 'values' property is not found in <paramref name="map" />.</exception>
private TypeSchema ParseMapType(JObject map, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
{
var valueType = map[Token.Values];
if (valueType == null)
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Property 'values' cannot be found inside the map '{0}'.", map));
}
var valueSchema = this.Parse(valueType, parent, namedSchemas);
return(new MapSchema(new StringSchema(), valueSchema, typeof(Dictionary <string, object>)));
}
/// <summary>
/// Parses a JSON object representing an Avro array.
/// </summary>
/// <param name="array">JSON representing the array.</param>
/// <param name="parent">The parent.</param>
/// <param name="namedSchemas">The named schemas.</param>
/// <returns>
/// A corresponding schema.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when no 'items' property is found in <paramref name="array" />.</exception>
private TypeSchema ParseArrayType(JObject array, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
{
var itemType = array[Token.Items];
if (itemType == null)
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Property 'items' cannot be found inside the array '{0}'.", array));
}
var elementSchema = this.Parse(itemType, parent, namedSchemas);
return(new ArraySchema(elementSchema, typeof(Array)));
}
/// <summary>
/// Parses the JSON object.
/// </summary>
/// <param name="token">The object.</param>
/// <param name="parent">The parent schema.</param>
/// <param name="namedSchemas">The schemas.</param>
/// <returns>
/// Schema internal representation.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when JSON schema type is invalid.</exception>
private TypeSchema ParseJsonObject(JObject token, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
{
JToken tokenType = token[Token.Type];
if (tokenType.Type == JTokenType.String)
{
var type = token.RequiredProperty <global::AvroConvert.Schema.Schema.Type>(Token.Type);
if (PrimitiveRuntimeType.ContainsKey(type.ToString()))
{
return(this.ParsePrimitiveTypeFromObject(token));
}
switch (type)
{
case global::AvroConvert.Schema.Schema.Type.Record:
return(this.ParseRecordType(token, parent, namedSchemas));
case global::AvroConvert.Schema.Schema.Type.Enumeration:
return(this.ParseEnumType(token, parent, namedSchemas));
case global::AvroConvert.Schema.Schema.Type.Array:
return(this.ParseArrayType(token, parent, namedSchemas));
case global::AvroConvert.Schema.Schema.Type.Map:
return(this.ParseMapType(token, parent, namedSchemas));
case global::AvroConvert.Schema.Schema.Type.Fixed:
return(this.ParseFixedType(token, parent));
default:
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Invalid type specified: '{0}'.", type));
}
}
if (tokenType.Type == JTokenType.Array)
{
return(this.ParseUnionType(tokenType as JArray, parent, namedSchemas));
}
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Invalid type specified: '{0}'.", tokenType));
}
/// <summary>
/// Parses the record field.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="parent">The parent schema.</param>
/// <param name="namedSchemas">The named schemas.</param>
/// <param name="position">The position.</param>
/// <returns>
/// Schema internal representation.
/// </returns>
/// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when <paramref name="field"/> is not valid or when sort order is not valid.</exception>
private RecordField ParseRecordField(JObject field, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas, int position)
{
var name = field.RequiredProperty <string>(Token.Name);
var doc = field.OptionalProperty <string>(Token.Doc);
var order = field.OptionalProperty <string>(Token.Order);
var aliases = this.GetAliases(field, parent.FullName);
var fieldType = field[Token.Type];
if (fieldType == null)
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Record field schema '{0}' has no type.", field));
}
TypeSchema type = this.Parse(fieldType, parent, namedSchemas);
object defaultValue = null;
bool hasDefaultValue = field[Token.Default] != null;
if (hasDefaultValue)
{
var objectParser = new JsonObjectParser();
defaultValue = objectParser.Parse(type, field[Token.Default].ToString());
}
var orderValue = SortOrder.Ascending;
if (!string.IsNullOrEmpty(order))
{
if (!SortValue.ContainsKey(order.ToUpperInvariant()))
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Invalid sort order of the field '{0}'.", order));
}
orderValue = SortValue[order.ToUpperInvariant()];
}
var fieldName = new SchemaName(name);
var attributes = new NamedEntityAttributes(fieldName, aliases, doc);
return(new RecordField(attributes, type, orderValue, hasDefaultValue, defaultValue, null, position));
}
private FixedSchema ParseFixedType(JObject type, NamedSchema parent)
{
var name = type.RequiredProperty <string>(Token.Name);
var nspace = this.GetNamespace(type, parent, name);
var fixedName = new SchemaName(name, nspace);
var size = type.RequiredProperty <int>(Token.Size);
if (size <= 0)
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "Only positive size of fixed values allowed: '{0}'.", size));
}
var aliases = this.GetAliases(type, fixedName.Namespace);
var attributes = new NamedEntityAttributes(fixedName, aliases, string.Empty);
var customAttributes = type.GetAttributesNotIn(StandardProperties.Record);
var result = new FixedSchema(attributes, size, typeof(byte[]), customAttributes);
return(result);
}
private FixedSchema TryBuildFixedSchema(Type memberType, MemberInfo memberInfo, NamedSchema parentSchema)
{
var result = memberInfo.GetCustomAttributes(false).OfType <AvroFixedAttribute>().FirstOrDefault();
if (result == null)
{
return(null);
}
if (memberType != typeof(byte[]))
{
throw new SerializationException(
string.Format(CultureInfo.InvariantCulture, "'{0}' can be set only to members of type byte[].", typeof(AvroFixedAttribute)));
}
var schemaNamespace = string.IsNullOrEmpty(result.Namespace) && !result.Name.Contains(".") && parentSchema != null
? parentSchema.Namespace
: result.Namespace;
return(new FixedSchema(
new NamedEntityAttributes(new SchemaName(result.Name, schemaNamespace), new List <string>(), string.Empty),
result.Size,
memberType));
}
private bool DoNamesMatch(NamedSchema w, NamedSchema r)
{
return(r.FullName == w.FullName || r.Aliases.Contains(w.FullName));
}