/// <summary> /// Serializes a "null" /// </summary> /// <param name="value">The object to be serialized using null schema</param> /// <param name="encoder">The encoder to use while serialization</param> protected void WriteNull(object value, Encoder encoder) { if (value != null) { throw TypeMismatch(value, "null", "null"); } }
/// <summary> /// Serialized a map. The default implementation first ensure that the value is indeed a map and then uses /// GetMapSize() and GetMapElements() to access the contents of the map. /// </summary> /// <param name="schema">The MapSchema for serialization</param> /// <param name="value">The value to be serialized</param> /// <param name="encoder">The encoder for serialization</param> protected void WriteMap(WriteItem itemWriter, object value, Encoder encoder) { _mapAccess.EnsureMapObject(value); encoder.WriteMapStart(); encoder.SetItemCount(_mapAccess.GetMapSize(value)); _mapAccess.WriteMapValues(value, itemWriter, encoder); encoder.WriteMapEnd(); }
public void WriteMapValues(object map, WriteItem valueWriter, Encoder encoder) { foreach (DictionaryEntry entry in ((IDictionary)map)) { encoder.StartItem(); encoder.WriteString(entry.Key.ToString()); valueWriter(entry.Value, encoder); } }
public void WriteArrayValues(object array, WriteItem valueWriter, Encoder encoder) { var list = (IList)array; for (int i = 0; i < list.Count; i++) { valueWriter(list[i], encoder); } }
protected override void WriteFixed(FixedSchema es, object value, Encoder encoder) { if (value == null || !(value is GenericFixed) || !(value as GenericFixed).Schema.Equals(es)) { throw TypeMismatch(value, "fixed", "GenericFixed"); } GenericFixed ba = (GenericFixed)value; encoder.WriteFixed(ba.Value); }
public void WriteArrayValues(object array, WriteItem valueWriter, Encoder encoder) { var arrayInstance = (Array)array; for (int i = 0; i < arrayInstance.Length; i++) { encoder.StartItem(); valueWriter(arrayInstance.GetValue(i), encoder); } }
private void WriteArray(WriteItem itemWriter, object array, Encoder encoder) { _arrayAccess.EnsureArrayObject(array); long l = _arrayAccess.GetArrayLength(array); encoder.WriteArrayStart(); encoder.SetItemCount(l); _arrayAccess.WriteArrayValues(array, itemWriter, encoder); encoder.WriteArrayEnd(); }
protected override void WriteFixed(FixedSchema schema, object value, Encoder encoder) { var fixedrec = value as SpecificFixed; if (fixedrec == null) { throw new AvroTypeException("Fixed object is not derived from SpecificFixed"); } encoder.WriteFixed(fixedrec.Value); }
protected override void WriteField(object record, string fieldName, int fieldPos, WriteItem writer, Encoder encoder) { writer(((GenericRecord)record)[fieldName], encoder); }
protected override void WriteRecordFields(object recordObj, RecordFieldWriter[] writers, Encoder encoder) { GenericRecord record = new GenericRecord((RecordSchema)_schema); if (recordObj is Dictionary <string, object> obj) { record.contents = obj; } else { record.contents = SplitKeyValues(recordObj); } foreach (var writer in writers) { writer.WriteField(record[writer.Field.Name], encoder); } }
protected override void WriteField(object record, string fieldName, int fieldPos, WriteItem writer, Encoder encoder) { writer(((ISpecificRecord)record).Get(fieldPos), encoder); }
protected override void WriteRecordFields(object recordObj, RecordFieldWriter[] writers, Encoder encoder) { var record = (ISpecificRecord)recordObj; for (int i = 0; i < writers.Length; i++) { var writer = writers[i]; writer.WriteField(record.Get(writer.Field.Pos), encoder); } }
protected abstract void WriteRecordFields(object record, RecordFieldWriter[] writers, Encoder encoder);
/// <summary> /// Serialized a fixed object. The default implementation requires that the value is /// a GenericFixed object with an identical schema as es. /// </summary> /// <param name="es">The schema for serialization</param> /// <param name="value">The value to be serialized</param> /// <param name="encoder">The encoder for serialization</param> protected abstract void WriteFixed(FixedSchema es, object value, Encoder encoder);
public void Write(T datum, Encoder encoder) { _writer(datum, encoder); }
/// <summary> /// Resolves the given value against the given UnionSchema and serializes the object against /// the resolved schema member. /// </summary> /// <param name="us">The UnionSchema to resolve against</param> /// <param name="value">The value to be serialized</param> /// <param name="encoder">The encoder for serialization</param> private void WriteUnion(UnionSchema unionSchema, Schema[] branchSchemas, WriteItem[] branchWriters, object value, Encoder encoder) { int index = ResolveUnion(unionSchema, branchSchemas, value); encoder.WriteUnionIndex(index); branchWriters[index](value, encoder); }
/// <summary> /// Extracts the field value from the given object. /// </summary> /// <param name="value">The record value from which the field needs to be extracted</param> /// <param name="fieldName">The name of the field in the record</param> /// <param name="fieldPos">The position of field in the record</param> /// <returns></returns> protected abstract void WriteField(object record, string fieldName, int fieldPos, WriteItem writer, Encoder encoder);