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()]));
}
