private byte[] ParseFixed(TypeSchema schema, string jsonObject) { var fixedSchema = (FixedSchema)schema; var result = ConvertToBytes(jsonObject); if (result.Length != fixedSchema.Size) { throw new SerializationException( string.Format(CultureInfo.InvariantCulture, "'{0}' size does not match the size of fixed schema node.", jsonObject)); } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="ArraySchema" /> class. /// </summary> /// <param name="item">The item.</param> /// <param name="runtimeType">Type of the runtime.</param> /// <param name="attributes">The attributes.</param> internal ArraySchema( TypeSchema item, Type runtimeType, Dictionary <string, string> attributes) : base(runtimeType, attributes) { if (item == null) { throw new ArgumentNullException("item"); } this.itemSchema = item; }
private void AddRecordFields( IEnumerable <MemberSerializationInfo> members, Dictionary <string, NamedSchema> schemas, uint currentDepth, RecordSchema record) { int index = 0; foreach (MemberSerializationInfo info in members) { var property = info.MemberInfo as PropertyInfo; var field = info.MemberInfo as FieldInfo; Type memberType; if (property != null) { memberType = property.PropertyType; } else if (field != null) { memberType = field.FieldType; } else { throw new SerializationException( string.Format( CultureInfo.InvariantCulture, "Type member '{0}' is not supported.", info.MemberInfo.GetType().Name)); } TypeSchema fieldSchema = this.TryBuildUnionSchema(memberType, info.MemberInfo, schemas, currentDepth) ?? this.TryBuildFixedSchema(memberType, info.MemberInfo, record) ?? this.CreateSchema(info.Nullable, memberType, schemas, currentDepth + 1, info.DefaultValue?.GetType()); var aliases = info .Aliases .ToList(); var recordField = new RecordField( new NamedEntityAttributes(new SchemaName(info.Name), aliases, info.Doc), fieldSchema, SortOrder.Ascending, info.HasDefaultValue, info.DefaultValue, info.MemberInfo, index++); record.AddField(recordField); } }
private AvroEnum ParseEnum(TypeSchema schema, string jsonObject) { var enumSchema = (EnumSchema)schema; if (!enumSchema.Symbols.Contains(jsonObject)) { throw new SerializationException( string.Format(CultureInfo.InvariantCulture, "'{0}' is not a valid enum value.", jsonObject)); } return(new AvroEnum(schema) { Value = jsonObject }); }
/// <summary> /// Parses a JSON string according to given schema and returns the corresponding object. /// </summary> /// <param name="schema">The schema.</param> /// <param name="json">The JSON object.</param> /// <returns>The object.</returns> public object Parse(TypeSchema schema, string json) { if (this.parsersWithoutSchema.ContainsKey(schema.GetType())) { return(this.parsersWithoutSchema[schema.GetType()](json)); } if (this.parsersWithSchema.ContainsKey(schema.GetType())) { return(this.parsersWithSchema[schema.GetType()](schema, json)); } throw new SerializationException( string.Format(CultureInfo.InvariantCulture, "Unknown schema type '{0}'.", schema.GetType())); }
/// <summary> /// Creates the avro schema for the specified type. /// </summary> /// <param name="type">The type.</param> /// <param name="schemas">The schemas seen so far.</param> /// <param name="currentDepth">The current depth.</param> /// <returns> /// New instance of schema. /// </returns> /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when maximum depth of object graph is reached.</exception> private TypeSchema CreateNotNullableSchema(Type type, Dictionary <string, NamedSchema> schemas, uint currentDepth) { TypeSchema schema = TryBuildPrimitiveTypeSchema(type); if (schema != null) { return(schema); } if ((type.IsInterface() || type.IsAbstract()) || this.HasApplicableKnownType(type)) { return(this.BuildKnownTypeSchema(type, schemas, currentDepth)); } return(this.BuildComplexTypeSchema(type, schemas, currentDepth)); }
/// <summary> /// Initializes a new instance of the <see cref="MapSchema" /> class. /// </summary> /// <param name="keySchema">The key schema.</param> /// <param name="valueSchema">The value schema.</param> /// <param name="runtimeType">Type of the runtime.</param> /// <param name="attributes">The attributes.</param> internal MapSchema( TypeSchema keySchema, TypeSchema valueSchema, Type runtimeType, Dictionary <string, string> attributes) : base(runtimeType, attributes) { if (keySchema == null) { throw new ArgumentNullException("keySchema"); } if (valueSchema == null) { throw new ArgumentNullException("valueSchema"); } this.valueSchema = valueSchema; this.keySchema = keySchema; }
private AvroRecord ParseRecord(TypeSchema schema, string jsonObject) { var recordSchema = (RecordSchema)schema; var result = new AvroRecord(recordSchema); var data = JsonConvert.DeserializeObject <Dictionary <string, JToken> >(jsonObject); foreach (var datum in data) { var matchedRecord = recordSchema.Fields.FirstOrDefault(field => field.Name == datum.Key); if (matchedRecord == null) { throw new SerializationException( string.Format(CultureInfo.InvariantCulture, "Could not set default value because JSON object contains fields that do not exist in the schema.")); } result[matchedRecord.Name] = this.Parse(matchedRecord.TypeSchema, datum.Value.ToString()); } return(result); }
/// <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)); }
/// <summary> /// Creates a <see cref="RecordField" /> instance. /// </summary> /// <param name="fieldName">The field name.</param> /// <param name="fieldType">The field type.</param> /// <returns>An instance of the <see cref="RecordField" />.</returns> public static RecordField CreateField(string fieldName, TypeSchema fieldType) { if (String.IsNullOrEmpty(fieldName)) { throw new ArgumentException("Field name is not allowed to be null or empty."); } if (fieldType == null) { throw new ArgumentNullException("fieldType"); } return(new RecordField( new NamedEntityAttributes(new SchemaName(fieldName), new List <string>(), String.Empty), fieldType, SortOrder.Ascending, false, null, null, -1)); }
/// <summary> /// Initializes a new instance of the <see cref="RecordField" /> class. /// </summary> /// <param name="namedEntityAttributes">The named entity attributes.</param> /// <param name="typeSchema">The type schema.</param> /// <param name="order">The order.</param> /// <param name="hasDefaultValue">Whether the field has a default value or not.</param> /// <param name="defaultValue">The default value.</param> /// <param name="info">The info.</param> /// <param name="position">The position of the field in the schema.</param> /// <param name="attributes">The attributes.</param> internal RecordField( NamedEntityAttributes namedEntityAttributes, TypeSchema typeSchema, SortOrder order, bool hasDefaultValue, object defaultValue, MemberInfo info, int position, Dictionary <string, string> attributes) : base(attributes) { this.namedEntityAttributes = namedEntityAttributes; this.typeSchema = typeSchema; this.order = order; this.hasDefaultValue = hasDefaultValue; this.defaultValue = defaultValue; this.info = info; this.position = position; this.ShouldBeSkipped = false; this.UseDefaultValue = false; }
/// <summary> /// Initializes a new instance of the <see cref="SurrogateSchema" /> class. /// </summary> /// <param name="originalType">Type of the original.</param> /// <param name="surrogateType">Type of the surrogate.</param> /// <param name="attributes">The attributes.</param> /// <param name="surrogateSchema">The surrogate schema.</param> internal SurrogateSchema( Type originalType, Type surrogateType, IDictionary <string, string> attributes, TypeSchema surrogateSchema) : base(originalType, attributes) { if (originalType == null) { throw new ArgumentNullException("originalType"); } if (surrogateType == null) { throw new ArgumentNullException("surrogateType"); } if (surrogateSchema == null) { throw new ArgumentNullException("surrogateSchema"); } this.surrogateType = surrogateType; this.surrogateSchema = surrogateSchema; }
internal SurrogateSchema(Type originalType, Type surrogateType, TypeSchema surrogateSchema) : this(originalType, surrogateType, new Dictionary <string, string>(), surrogateSchema) { }
/// <summary> /// Initializes a new instance of the <see cref="ArraySchema"/> class. /// </summary> /// <param name="item">The item.</param> /// <param name="runtimeType">Type of the runtime.</param> internal ArraySchema( TypeSchema item, Type runtimeType) : this(item, runtimeType, new Dictionary <string, string>()) { }
internal MapSchema(TypeSchema keySchema, TypeSchema valueSchema, Type runtimeType) : this(keySchema, valueSchema, runtimeType, new Dictionary <string, string>()) { }
/// <summary> /// Implements double dispatch. /// </summary> /// <param name="w">The writer schema.</param> /// <param name="r">The reader schema.</param> /// <returns>True if match.</returns> private TypeSchema BuildDynamic(TypeSchema w, TypeSchema r) { return(this.BuildCore((dynamic)w, (dynamic)r)); }
/// <summary> /// Creates a <see cref="ArraySchema" /> instance. /// </summary> /// <param name="itemSchema">The schema of the items.</param> /// <returns>An instance of the <see cref="ArraySchema" />.</returns> public static ArraySchema CreateArray(TypeSchema itemSchema) { return(new ArraySchema(itemSchema, typeof(Array))); }
internal NullableSchema( Type nullableType, TypeSchema valueSchema) : this(nullableType, new Dictionary <string, string>(), valueSchema) { }
/// <summary> /// Creates a <see cref="MapSchema" /> instance. /// </summary> /// <param name="valueSchema">The schema of the values.</param> /// <returns>An instance of the <see cref="MapSchema" />.</returns> public static MapSchema CreateMap(TypeSchema valueSchema) { return(new MapSchema(new StringSchema(), valueSchema, typeof(Dictionary <,>))); }
/// <summary> /// If reader's is a union, but writer's is not the first schema in the reader's union /// that matches the writer's schema is recursively resolved against it. If none match, an error is signalled. /// </summary> /// <param name="w">The writer schema.</param> /// <param name="r">The reader schema.</param> /// <returns>True if match.</returns> private TypeSchema BuildCore(TypeSchema w, UnionSchema r) { return(r.Schemas.Select(rs => this.BuildDynamic(w, rs)).SingleOrDefault(s => s != null)); }
public TypeSchema Build(TypeSchema w, TypeSchema r) { this.visited.Clear(); return(this.BuildDynamic(w, r)); }
private object ParseUnion(TypeSchema schema, string jsonObject) { var unionSchema = (UnionSchema)schema; return(this.Parse(unionSchema.Schemas[0], jsonObject)); }