protected override WriteItem ResolveEnum(EnumSchema es) { List <String> enumNames = new List <string>(); foreach (var field in typeof(EnumSchema).GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static)) { if (field.IsLiteral) { enumNames.Add(field.Name); } } int length = enumNames.ToArray().Length; var translator = new int[length]; for (int i = 0; i < length; i++) { if (es.Contains(enumNames[i])) { translator[i] = es.Ordinal(enumNames[i]); } else { translator[i] = -1; } } return((v, e) => { if (v == null) { throw new BaijiTypeException("value is null in SpecificDatumWriter.WriteEnum"); } e.WriteEnum(es.Ordinal(v.ToString())); }); }
private ReadItem ResolveEnum(EnumSchema writerSchema, EnumSchema readerSchema) { var enumAccess = GetEnumAccess(readerSchema); if (readerSchema.Equals(writerSchema)) { return((r, d) => enumAccess.CreateEnum(r, d.ReadEnum())); } var translator = new int[writerSchema.Symbols.Count]; foreach (var symbol in writerSchema.Symbols) { var writerOrdinal = writerSchema.Ordinal(symbol); if (readerSchema.Contains(symbol)) { translator[writerOrdinal] = readerSchema.Ordinal(symbol); } else { translator[writerOrdinal] = -1; } } return((r, d) => { var writerOrdinal = d.ReadEnum(); var readerOrdinal = translator[writerOrdinal]; if (readerOrdinal == -1) { throw new AvroException("No such symbol: " + writerSchema[writerOrdinal]); } return enumAccess.CreateEnum(r, readerOrdinal); }); }
/// <summary> /// Serializes an enumeration. The default implementation expectes the value to be string whose /// value is the name of the enumeration. /// </summary> /// <param name="es">The EnumSchema for serialization</param> /// <param name="value">Value to be written</param> /// <param name="encoder">Encoder for serialization</param> protected virtual void WriteEnum(EnumSchema es, object value, Encoder encoder) { if (value == null || !(value is GenericEnum) || !((value as GenericEnum).Schema.Equals(es))) { throw TypeMismatch(value, "enum", "GenericEnum"); } encoder.WriteEnum(es.Ordinal((value as GenericEnum).Value)); }
/// <summary> /// Writes the given enum value into the given encoder. /// </summary> /// <param name="schema">writer schema</param> /// <param name="value">enum value</param> /// <param name="encoder">encoder to write to</param> protected override void WriteEnum(EnumSchema schema, object value, Encoder encoder) { if (value == null) { throw new AvroTypeException("value is null in SpecificDefaultWriter.WriteEnum"); } encoder.WriteEnum(schema.Ordinal(value.ToString())); }
/// <inheritdoc/> protected override WriteItem ResolveEnum(EnumSchema es) { var type = ObjectCreator.Instance.GetType(es); var enumNames = Enum.GetNames(type); var translator = new int[enumNames.Length]; for (int i = 0; i < enumNames.Length; i++) { if (es.Contains(enumNames[i])) { translator[i] = es.Ordinal(enumNames[i]); } else { translator[i] = -1; } } return((v, e) => { if (v == null) { throw new AvroTypeException("value is null in SpecificDefaultWriter.WriteEnum"); } if (v.GetType() == type) { int translated = translator[(int)v]; if (translated == -1) { throw new AvroTypeException("Unknown enum value:" + v.ToString()); } else { e.WriteEnum(translated); } } else { e.WriteEnum(es.Ordinal(v.ToString())); } }); }
/// <inheritdoc/> protected override WriteItem ResolveEnum(EnumSchema es) { return((v, e) => { if (v == null || !(v is GenericEnum) || !(v as GenericEnum).Schema.Equals(es)) { throw TypeMismatch(v, "enum", "GenericEnum"); } e.WriteEnum(es.Ordinal((v as GenericEnum).Value)); }); }
internal Encoder.WriteItem Resolve(EnumSchema schema) { return((value, e) => { if (!schema.Contains(value.ToString())) { throw new AvroTypeException( $"[Enum] Provided value is not of the enum [{schema.Name}] members"); } e.WriteEnum(schema.Ordinal(value.ToString())); }); }
public Encoder.WriteItem Resolve(EnumSchema es) { return((value, e) => { if (!(value is Models.Enum) || !((Models.Enum)value).Schema.Equals(es)) { throw new AvroTypeMismatchException( "[GenericEnum] required to write against [Enum] schema but found " + value.GetType()); } e.WriteEnum(es.Ordinal(((Models.Enum)value).Value)); }); }
/// <summary> /// Reads an enum from the given decoder /// </summary> /// <param name="reuse">object to store data read</param> /// <param name="writerSchema">schema of the object that wrote the data</param> /// <param name="readerSchema">schema of the object that will store the data</param> /// <param name="dec">decoder object that contains the data to be read</param> /// <returns>enum value</returns> protected override object ReadEnum(object reuse, EnumSchema writerSchema, Schema readerSchema, Decoder dec) { EnumSchema rs = readerSchema as EnumSchema; return(rs.Ordinal(writerSchema[dec.ReadEnum()])); }