public override void Write(object value, ProtoWriter dest) { IList arr = (IList)value; int len = arr.Count; SubItemToken token; bool writePacked = (options & OPTIONS_WritePacked) != 0; if (writePacked) { ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, dest); token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.SetPackedField(fieldNumber, dest); } else { token = new SubItemToken(); // default } bool checkForNull = !SupportNull; for (int i = 0; i < len; i++) { object obj = arr[i]; if (checkForNull && obj == null) { throw new NullReferenceException(); } Tail.Write(obj, dest); } if (writePacked) { ProtoWriter.EndSubItem(token, dest); } }
public override void Write(object untyped, ProtoWriter dest) { foreach (var pair in (TDictionary)untyped) { ProtoWriter.WriteFieldHeader(fieldNumber, wireType, dest); var token = ProtoWriter.StartSubItem(null, dest); if (pair.Key != null) { keyTail.Write(pair.Key, dest); } if (pair.Value != null) { Tail.Write(pair.Value, dest); } ProtoWriter.EndSubItem(token, dest); } }
public override void Write(object value, ProtoWriter dest) { SubItemToken token; bool writePacked = WritePacked; bool fixedSizePacked = writePacked & CanUsePackedPrefix(value) && value is ICollection; if (writePacked) { ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, dest); if (fixedSizePacked) { ProtoWriter.WritePackedPrefix(((ICollection)value).Count, packedWireType, dest); token = default(SubItemToken); } else { token = ProtoWriter.StartSubItem(value, dest); } ProtoWriter.SetPackedField(fieldNumber, dest); } else { token = new SubItemToken(); // default } bool checkForNull = !SupportNull; foreach (object subItem in (IEnumerable)value) { if (checkForNull && subItem == null) { throw new NullReferenceException(); } Tail.Write(subItem, dest); } if (writePacked) { if (fixedSizePacked) { ProtoWriter.ClearPackedField(fieldNumber, dest); } else { ProtoWriter.EndSubItem(token, dest); } } }
public void Write(object value, Action metaWriter, Action prepareInstance, ProtoWriter dest) { SubItemToken token = new SubItemToken(); int fieldNumber = dest.FieldNumber; bool writePacked = _writePacked; if (_protoCompatibility) { // empty arrays are nulls, no subitem or field if (writePacked) { token = ProtoWriter.StartSubItem(null, true, dest); } else // each element will begin its own header { ProtoWriter.WriteFieldHeaderCancelBegin(dest); } WriteContent( value, fieldNumber, _writePacked, dest, first: prepareInstance); if (writePacked) { // last element - end subitem ProtoWriter.EndSubItem(token, dest); } } else { bool pack = _tail.DemandWireTypeStabilityStatus(); token = ProtoWriter.StartSubItem(null, pack, dest); metaWriter?.Invoke(); prepareInstance?.Invoke(); WriteContent(value, FieldItem, pack, dest); ProtoWriter.EndSubItem(token, dest); } }
public override void Write(ProtoWriter dest, ref ProtoWriter.State state, object value) { foreach (var pair in (TDictionary)value) { ProtoWriter.WriteFieldHeader(fieldNumber, wireType, dest, ref state); var token = ProtoWriter.StartSubItem(null, dest, ref state); if (pair.Key != null) { keyTail.Write(dest, ref state, pair.Key); } if (pair.Value != null) { Tail.Write(dest, ref state, pair.Value); } ProtoWriter.EndSubItem(token, dest, ref state); } }
private static void WriteRecords(IDataReader reader, List <ProtoBufDataColumn> columns, ProtoWriter writer) { ProtoWriter.WriteFieldHeader(FieldHeaders.Records, WireType.StartGroup, writer); var recordsToken = ProtoWriter.StartSubItem(reader, writer); var recordIndex = 0; while (reader.Read()) { WriteRecord(reader, columns, writer, recordIndex); recordIndex++; } ProtoWriter.EndSubItem(recordsToken, writer); }
void Write(MetaType metaType, Type actual, ProtoWriter dest, int recursionLevel) { if (metaType.Type != actual) { foreach (var subType in metaType.GetSubtypes().OrderBy(st => st.FieldNumber)) { MetaType derivedType = subType.DerivedType; if (derivedType.Type == metaType.Type) { continue; } if (Helpers.IsAssignableFrom(derivedType.Type, actual)) { if (recursionLevel == 0) { if (derivedType.Type == actual) { ProtoWriter.WriteFieldHeaderComplete(WireType.Variant, dest); ProtoWriter.WriteInt32(subType.FieldNumber + 1, dest); return; } var token = ProtoWriter.StartSubItem(null, true, dest); ProtoWriter.WriteFieldHeaderIgnored(WireType.Variant, dest); ProtoWriter.WriteInt32(subType.FieldNumber + 1, dest); Write(derivedType, actual, dest, 1); ProtoWriter.EndSubItem(token, dest); } else { ProtoWriter.WriteFieldHeaderIgnored(WireType.Variant, dest); ProtoWriter.WriteInt32(subType.FieldNumber + 1, dest); Write(derivedType, actual, dest, recursionLevel + 1); } return; } } } if (recursionLevel == 0) { ProtoWriter.WriteFieldHeaderComplete(WireType.Variant, dest); ProtoWriter.WriteInt32(0, dest); } }
public void Write(object value, ProtoWriter dest) { UnityEngine.Vector3 data = (UnityEngine.Vector3)value; SubItemToken token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.WriteFieldHeader(1, WireType.Fixed32, dest); ProtoWriter.WriteSingle(data.x, dest); ProtoWriter.WriteFieldHeader(2, WireType.Fixed32, dest); ProtoWriter.WriteSingle(data.y, dest); ProtoWriter.WriteFieldHeader(3, WireType.Fixed32, dest); ProtoWriter.WriteSingle(data.z, dest); ProtoWriter.EndSubItem(token, dest); }
public void Write(object value, ProtoWriter dest) { var token = ProtoWriter.StartSubItem(value, _prefixLength, dest); for (int i = 0; i < _tails.Length; i++) { object val = GetValue(value, i); // this is the only place where we don't use null check from NetObjectValueDecorator // members of Tuple can't have default values so we don't mix up default value and null // (default value simply don't write the field while NetObjectValueDecorator explicitely writes empty group) // so this simple check will be more size-efficient if (val != null) { ProtoWriter.WriteFieldHeaderBegin(i + 1, dest); _tails[i].Write(val, dest); } } ProtoWriter.EndSubItem(token, dest); }
public void ShouldThrowExceptionOnColumnsInvalidFieldHeader() { // Arrange var stream = new MemoryStream(); using (var writer = new ProtoWriter(stream, null, null)) { ProtoWriter.WriteFieldHeader(1, WireType.StartGroup, writer); ProtoWriter.StartSubItem(0, writer); ProtoWriter.WriteFieldHeader(42, WireType.StartGroup, writer); } stream.Position = 0; // Assert Assert.Throws <InvalidDataException>(() => new ProtoDataReader(stream)); }
private void WriteHeaderIfRequired() { if (isHeaderWritten) { return; } ProtoWriter.WriteFieldHeader(1, WireType.StartGroup, writer); currentResultToken = ProtoWriter.StartSubItem(resultIndex, writer); IList <ProtoDataColumn> columns = columnFactory.GetColumns(reader, options); new HeaderWriter(writer).WriteHeader(columns); rowWriter = new RowWriter(writer, columns, options); isHeaderWritten = true; }
public override void Write(object value, ProtoWriter dest) { bool writePacked = this.WritePacked; SubItemToken token; if (writePacked) { ProtoWriter.WriteFieldHeader(this.fieldNumber, WireType.String, dest); token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.SetPackedField(this.fieldNumber, dest); } else { token = default(SubItemToken); } bool flag = !this.SupportNull; IEnumerator enumerator = ((IEnumerable)value).GetEnumerator(); try { while (enumerator.MoveNext()) { object current = enumerator.get_Current(); if (flag && current == null) { throw new NullReferenceException(); } this.Tail.Write(current, dest); } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } if (writePacked) { ProtoWriter.EndSubItem(token, dest); } }
public void WriteHeader(IEnumerable <ProtoDataColumn> columns) { if (columns == null) { throw new ArgumentNullException("columns"); } foreach (ProtoDataColumn column in columns) { // for each, write the name and data type ProtoWriter.WriteFieldHeader(2, WireType.StartGroup, this.writer); SubItemToken columnToken = ProtoWriter.StartSubItem(column, this.writer); ProtoWriter.WriteFieldHeader(1, WireType.String, this.writer); ProtoWriter.WriteString(column.Name, this.writer); ProtoWriter.WriteFieldHeader(2, WireType.Variant, this.writer); ProtoWriter.WriteInt32((int)column.ProtoDataType, this.writer); ProtoWriter.EndSubItem(columnToken, this.writer); } }
public void ShouldAcceptTrailingFieldHeaders() { // Arrange var stream = new MemoryStream(); using (var writer = ProtoWriter.Create(stream, null, null)) { ProtoWriter.WriteFieldHeader(1, WireType.StartGroup, writer); var resultToken = ProtoWriter.StartSubItem(0, writer); ProtoWriter.WriteFieldHeader(2, WireType.StartGroup, writer); var columnToken = ProtoWriter.StartSubItem(1, writer); ProtoWriter.WriteFieldHeader(1, WireType.String, writer); ProtoWriter.WriteString("foo", writer); ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer); ProtoWriter.WriteInt32((int)3, writer); ProtoWriter.EndSubItem(columnToken, writer); ProtoWriter.WriteFieldHeader(3, WireType.StartGroup, writer); var recordToken = ProtoWriter.StartSubItem(1, writer); ProtoWriter.WriteFieldHeader(1, WireType.Variant, writer); ProtoWriter.WriteInt32((int)1, writer); ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer); ProtoWriter.WriteInt32((int)1, writer); ProtoWriter.EndSubItem(recordToken, writer); ProtoWriter.EndSubItem(resultToken, writer); } stream.Position = 0; var dataReader = new ProtoDataReader(stream); // Assert dataReader.Read(); }
public override void Write(object value, ProtoWriter dest) { SubItemToken token; bool writePacked = WritePacked; if (writePacked) { ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, dest); token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.SetPackedField(fieldNumber, dest); } else { token = new SubItemToken(); // default } bool checkForNull = !SupportNull; foreach (object subItem in (IEnumerable)value) { if (checkForNull && subItem == null) { throw new NullReferenceException(); } Tail.Write(subItem, dest); } if (writePacked) { ProtoWriter.EndSubItem(token, dest); } }
public void Write(object value, ProtoWriter dest) { UnityEngine.Color32 data = (UnityEngine.Color32)value; SubItemToken token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.WriteFieldHeader(1, WireType.Variant, dest); ProtoWriter.WriteByte(data.r, dest); ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest); ProtoWriter.WriteByte(data.g, dest); ProtoWriter.WriteFieldHeader(3, WireType.Variant, dest); ProtoWriter.WriteByte(data.b, dest); ProtoWriter.WriteFieldHeader(4, WireType.Variant, dest); ProtoWriter.WriteByte(data.a, dest); ProtoWriter.EndSubItem(token, dest); }
public void Write(object value, ProtoWriter dest) { UnityEngine.AnimationCurve data = (UnityEngine.AnimationCurve)value; SubItemToken token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.WriteFieldHeader(1, WireType.Variant, dest); ProtoWriter.WriteInt32((int)data.preWrapMode, dest); ProtoWriter.WriteFieldHeader(2, WireType.Variant, dest); ProtoWriter.WriteInt32((int)data.postWrapMode, dest); for (int i = 0; i < data.keys.Length; ++i) { ProtoWriter.WriteFieldHeader(3, WireType.String, dest); this.keyframeSerializer.Write(data.keys[i], dest); } ProtoWriter.EndSubItem(token, dest); }
public void Write(object value, ProtoWriter dest) { var token = ProtoWriter.StartSubItem(value, _prefixLength, dest); if (_isRootType) { Callback(value, TypeModel.CallbackType.BeforeSerialize, dest.Context); } // write inheritance first IProtoSerializerWithWireType next; int fn; if (GetMoreSpecificSerializer(value, out next, out fn)) { ProtoWriter.WriteFieldHeaderBegin(fn, dest); next.Write(value, dest); } // write all actual fields //Helpers.DebugWriteLine(">> Writing fields for " + forType.FullName); for (int i = 0; i < _serializers.Length; i++) { IProtoSerializer ser = _serializers[i]; if (ser.ExpectedType == ExpectedType) { ProtoWriter.WriteFieldHeaderBegin(_fieldNumbers[i], dest); //Helpers.DebugWriteLine(": " + ser.ToString()); ser.Write(value, dest); } } //Helpers.DebugWriteLine("<< Writing fields for " + forType.FullName); if (_isExtensible) { ProtoWriter.AppendExtensionData((IExtensible)value, dest); } if (_isRootType) { Callback(value, TypeModel.CallbackType.AfterSerialize, dest.Context); } ProtoWriter.EndSubItem(token, dest); }
public void AddChannel(Channel channel) { ProtoWriter.WriteFieldHeader(2, WireType.StartGroup, writer); var channelTok = ProtoWriter.StartSubItem(null, writer); if (channel.Name != null) { ProtoWriter.WriteFieldHeader(1, WireType.String, writer); ProtoWriter.WriteString(channel.Name, writer); } var list = channel.Points; if (list != null) { switch (list.Count) { case 0: // nothing to write break; case 1: ProtoWriter.WriteFieldHeader(2, WireType.Fixed32, writer); ProtoWriter.WriteSingle(list[0], writer); break; default: ProtoWriter.WriteFieldHeader(2, WireType.String, writer); var dataToken = ProtoWriter.StartSubItem(null, writer); ProtoWriter.SetPackedField(2, writer); foreach (var val in list) { ProtoWriter.WriteFieldHeader(2, WireType.Fixed32, writer); ProtoWriter.WriteSingle(val, writer); } ProtoWriter.EndSubItem(dataToken, writer); break; } } ProtoWriter.EndSubItem(channelTok, writer); }
public void Write(object value, ProtoWriter dest) { UnityEngine.Keyframe data = (UnityEngine.Keyframe)value; SubItemToken token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.WriteFieldHeader(1, WireType.Fixed32, dest); ProtoWriter.WriteSingle(data.time, dest); ProtoWriter.WriteFieldHeader(2, WireType.Fixed32, dest); ProtoWriter.WriteSingle(data.value, dest); ProtoWriter.WriteFieldHeader(3, WireType.Fixed32, dest); ProtoWriter.WriteSingle(data.inTangent, dest); ProtoWriter.WriteFieldHeader(4, WireType.Fixed32, dest); ProtoWriter.WriteSingle(data.outTangent, dest); ProtoWriter.WriteFieldHeader(5, WireType.Variant, dest); ProtoWriter.WriteInt32(data.tangentMode, dest); ProtoWriter.EndSubItem(token, dest); }
public void Write(object value, ProtoWriter dest) { UnityEngine.Gradient data = (UnityEngine.Gradient)value; SubItemToken token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.WriteFieldHeader(1, WireType.Variant, dest); ProtoWriter.WriteInt32((int)data.mode, dest); for (int i = 0; i < data.alphaKeys.Length; ++i) { ProtoWriter.WriteFieldHeader(2, WireType.String, dest); this.alphaKeySerializer.Write(data.alphaKeys[i], dest); } for (int i = 0; i < data.colorKeys.Length; ++i) { ProtoWriter.WriteFieldHeader(3, WireType.String, dest); this.colorKeySerializer.Write(data.colorKeys[i], dest); } ProtoWriter.EndSubItem(token, dest); }
public void Write(object value, ProtoWriter dest) { ProtoWriter.ExpectRoot(dest); if (_protoCompatibility) { _serializer.Write(value, dest); return; } int typeKey; object obj; int refKey; var rootToken = ProtoWriter.StartSubItem(null, false, dest); ProtoWriter.WriteFieldHeaderBegin(CurrentFormatVersion, dest); _serializer.Write(value, dest); while (ProtoWriter.TryGetNextLateReference(out typeKey, out obj, out refKey, dest)) { ProtoWriter.WriteFieldHeaderBegin(refKey + 1, dest); ProtoWriter.WriteRecursionSafeObject(obj, typeKey, dest); } ProtoWriter.EndSubItem(rootToken, dest); }
public override void Write(object value, ProtoWriter dest) { if (packedFieldNumber > 0) { IEnumerator iter = ((IEnumerable)value).GetEnumerator(); using (iter as IDisposable) { if (iter.MoveNext()) { ProtoWriter.WriteFieldHeader(packedFieldNumber, WireType.String, dest); SubItemToken token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.SetPackedField(packedFieldNumber, dest); do { object subItem = iter.Current; if (subItem == null) { throw new NullReferenceException(); } Tail.Write(subItem, dest); } while (iter.MoveNext()); ProtoWriter.EndSubItem(token, dest); } } } else { foreach (object subItem in (IEnumerable)value) { if (subItem == null) { throw new NullReferenceException(); } Tail.Write(subItem, dest); } } }
public override void Write(object value, ProtoWriter dest) { IList arr = (IList)value; int len = arr.Count; if (packedFieldNumber > 0) { if (len != 0) { ProtoWriter.WriteFieldHeader(packedFieldNumber, WireType.String, dest); SubItemToken token = ProtoWriter.StartSubItem(value, dest); ProtoWriter.SetPackedField(packedFieldNumber, dest); for (int i = 0; i < len; i++) { object obj = arr[i]; if (obj == null) { throw new NullReferenceException(); } Tail.Write(obj, dest); } ProtoWriter.EndSubItem(token, dest); } } else { for (int i = 0; i < len; i++) { object obj = arr[i]; if (obj == null) { throw new NullReferenceException(); } Tail.Write(obj, dest); } } }
internal bool TrySerializeAuxiliaryType(ProtoWriter writer, Type type, DataFormat format, int tag, object value, bool isInsideList) { if (type == null) { type = value.GetType(); } ProtoTypeCode typeCode = Helpers.GetTypeCode(type); int modelKey; WireType wireType = GetWireType(typeCode, format, ref type, out modelKey); if (modelKey >= 0) { if (Helpers.IsEnum(type)) { Serialize(modelKey, value, writer); return(true); } ProtoWriter.WriteFieldHeader(tag, wireType, writer); switch (wireType) { case WireType.None: throw ProtoWriter.CreateException(writer); case WireType.String: case WireType.StartGroup: { SubItemToken token = ProtoWriter.StartSubItem(value, writer); Serialize(modelKey, value, writer); ProtoWriter.EndSubItem(token, writer); return(true); } default: Serialize(modelKey, value, writer); return(true); } } if (wireType != WireType.None) { ProtoWriter.WriteFieldHeader(tag, wireType, writer); } switch (typeCode) { case ProtoTypeCode.Int16: ProtoWriter.WriteInt16((short)value, writer); return(true); case ProtoTypeCode.Int32: ProtoWriter.WriteInt32((int)value, writer); return(true); case ProtoTypeCode.Int64: ProtoWriter.WriteInt64((long)value, writer); return(true); case ProtoTypeCode.UInt16: ProtoWriter.WriteUInt16((ushort)value, writer); return(true); case ProtoTypeCode.UInt32: ProtoWriter.WriteUInt32((uint)value, writer); return(true); case ProtoTypeCode.UInt64: ProtoWriter.WriteUInt64((ulong)value, writer); return(true); case ProtoTypeCode.Boolean: ProtoWriter.WriteBoolean((bool)value, writer); return(true); case ProtoTypeCode.SByte: ProtoWriter.WriteSByte((sbyte)value, writer); return(true); case ProtoTypeCode.Byte: ProtoWriter.WriteByte((byte)value, writer); return(true); case ProtoTypeCode.Char: ProtoWriter.WriteUInt16((char)value, writer); return(true); case ProtoTypeCode.Double: ProtoWriter.WriteDouble((double)value, writer); return(true); case ProtoTypeCode.Single: ProtoWriter.WriteSingle((float)value, writer); return(true); case ProtoTypeCode.DateTime: BclHelpers.WriteDateTime((DateTime)value, writer); return(true); case ProtoTypeCode.Decimal: BclHelpers.WriteDecimal((decimal)value, writer); return(true); case ProtoTypeCode.String: ProtoWriter.WriteString((string)value, writer); return(true); case ProtoTypeCode.ByteArray: ProtoWriter.WriteBytes((byte[])value, writer); return(true); case ProtoTypeCode.TimeSpan: BclHelpers.WriteTimeSpan((TimeSpan)value, writer); return(true); case ProtoTypeCode.Guid: BclHelpers.WriteGuid((Guid)value, writer); return(true); case ProtoTypeCode.Uri: ProtoWriter.WriteString(((Uri)value).AbsoluteUri, writer); return(true); default: { IEnumerable enumerable = value as IEnumerable; if (enumerable != null) { if (isInsideList) { throw CreateNestedListsNotSupported(); } foreach (object item in enumerable) { if (item == null) { throw new NullReferenceException(); } if (!TrySerializeAuxiliaryType(writer, null, format, tag, item, isInsideList: true)) { ThrowUnexpectedType(item.GetType()); } } return(true); } return(false); } } }
static void ProtoWrite(DataTable table, Stream stream) { using (var writer = new ProtoWriter(stream, null, null)) { // table name if (!string.IsNullOrEmpty(table.TableName)) { ProtoWriter.WriteFieldHeader(1, WireType.String, writer); ProtoWriter.WriteString(table.TableName, writer); } // write the schema: var cols = table.Columns; Action <object>[] colWriters = new Action <object> [cols.Count]; int i = 0; foreach (DataColumn col in cols) { // for each, write the name and data type ProtoWriter.WriteFieldHeader(2, WireType.StartGroup, writer); var token = ProtoWriter.StartSubItem(col, writer); ProtoWriter.WriteFieldHeader(1, WireType.String, writer); ProtoWriter.WriteString(col.ColumnName, writer); ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer); MappedType type; switch (Type.GetTypeCode(col.DataType)) { case TypeCode.Decimal: type = MappedType.Decimal; break; case TypeCode.Int16: type = MappedType.Int16; break; case TypeCode.Int32: type = MappedType.Int32; break; case TypeCode.String: type = MappedType.String; break; case TypeCode.DateTime: type = MappedType.DateTime; break; default: if (col.DataType == typeof(Guid)) { type = MappedType.Guid; break; } throw new NotSupportedException(col.DataType.Name); } ProtoWriter.WriteInt32((int)type, writer); ProtoWriter.EndSubItem(token, writer); int field = i + 1; Action <object> colWriter; switch (type) { case MappedType.String: colWriter = value => { ProtoWriter.WriteFieldHeader(field, WireType.String, writer); ProtoWriter.WriteString((string)value, writer); }; break; case MappedType.Int16: colWriter = value => { ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer); ProtoWriter.WriteInt16((short)value, writer); }; break; case MappedType.Decimal: colWriter = value => { ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer); BclHelpers.WriteDecimal((decimal)value, writer); }; break; case MappedType.Int32: colWriter = value => { ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer); ProtoWriter.WriteInt32((int)value, writer); }; break; case MappedType.Guid: colWriter = value => { ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer); BclHelpers.WriteGuid((Guid)value, writer); }; break; case MappedType.DateTime: colWriter = value => { ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer); BclHelpers.WriteDateTime((DateTime)value, writer); }; break; default: throw new NotSupportedException(col.DataType.Name); } colWriters[i++] = colWriter; } // write the rows foreach (DataRow row in table.Rows) { i = 0; ProtoWriter.WriteFieldHeader(3, WireType.StartGroup, writer); var token = ProtoWriter.StartSubItem(row, writer); foreach (DataColumn col in cols) { var value = row[col]; if (value == null || value is DBNull) { } else { colWriters[i](value); } i++; } ProtoWriter.EndSubItem(token, writer); } } }
/// <summary> /// 写出数据 /// </summary> /// <param name="writer">写出目标</param> /// <param name="obj">写出对象</param> /// <param name="field_desc">字段描述</param> /// <see cref="https://developers.google.com/protocol-buffers/docs/encoding"/> private void write_object(ProtoWriter writer, object obj, FieldDescriptorProto field_desc) { try { switch (field_desc.type) { case FieldDescriptorProto.Type.TYPE_DOUBLE: { double val = Convert.ToDouble(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed64, writer); ProtoWriter.WriteDouble(val, writer); break; } case FieldDescriptorProto.Type.TYPE_FLOAT: { float val = Convert.ToSingle(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed32, writer); ProtoWriter.WriteSingle(val, writer); break; } case FieldDescriptorProto.Type.TYPE_SINT64: case FieldDescriptorProto.Type.TYPE_INT64: { long val = Convert.ToInt64(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer); ProtoWriter.WriteInt64(val, writer); break; } case FieldDescriptorProto.Type.TYPE_UINT64: { ulong val = Convert.ToUInt64(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer); ProtoWriter.WriteUInt64(val, writer); break; } case FieldDescriptorProto.Type.TYPE_SINT32: case FieldDescriptorProto.Type.TYPE_INT32: { int val = Convert.ToInt32(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer); ProtoWriter.WriteInt32(val, writer); break; } case FieldDescriptorProto.Type.TYPE_FIXED64: { long val = Convert.ToInt64(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed64, writer); ProtoWriter.WriteInt64(val, writer); break; } case FieldDescriptorProto.Type.TYPE_FIXED32: { int val = Convert.ToInt32(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed32, writer); ProtoWriter.WriteInt32(val, writer); break; } case FieldDescriptorProto.Type.TYPE_BOOL: { bool val = Convert.ToBoolean(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer); ProtoWriter.WriteBoolean(val, writer); break; } case FieldDescriptorProto.Type.TYPE_STRING: { string val = Convert.ToString(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.String, writer); ProtoWriter.WriteString(val, writer); break; } //case FieldDescriptorProto.Type.TYPE_GROUP: // deprecated // break; case FieldDescriptorProto.Type.TYPE_MESSAGE: if (!(obj is DynamicMessage)) { lastError.AddLast(string.Format("try add {0} to {1}.{2}.{3}, but not a message", obj.ToString(), msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name)); break; } ProtoWriter.WriteFieldHeader(field_desc.number, WireType.String, writer); SubItemToken token = ProtoWriter.StartSubItem(null, writer); try { ((DynamicMessage)obj).Serialize(writer); } catch (Exception e) { lastError.AddLast(string.Format("{0}.{1}.{2} => {3}", msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name, e.Message)); } ProtoWriter.EndSubItem(token, writer); break; case FieldDescriptorProto.Type.TYPE_BYTES: { if (!(obj is byte[])) { throw new ArgumentException("{0} should be a byte[]", field_desc.name); } ProtoWriter.WriteFieldHeader(field_desc.number, WireType.String, writer); ProtoWriter.WriteBytes((byte[])obj, writer); break; } case FieldDescriptorProto.Type.TYPE_UINT32: { uint val = Convert.ToUInt32(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer); ProtoWriter.WriteUInt32(val, writer); break; } case FieldDescriptorProto.Type.TYPE_ENUM: { int val = Convert.ToInt32(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Variant, writer); ProtoWriter.WriteInt32(val, writer); break; } case FieldDescriptorProto.Type.TYPE_SFIXED32: { uint val = Convert.ToUInt32(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed32, writer); ProtoWriter.WriteUInt32(val, writer); break; } case FieldDescriptorProto.Type.TYPE_SFIXED64: { ulong val = Convert.ToUInt64(obj); ProtoWriter.WriteFieldHeader(field_desc.number, WireType.Fixed64, writer); ProtoWriter.WriteUInt64(val, writer); break; } default: // unsupported field lastError.AddLast(string.Format("field type {0} in {1}.{2}.{3} unsupported", field_desc.type.ToString(), msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name)); break; } } catch (Exception e) { lastError.AddLast(string.Format("{0}.{1}.{2} {3}", msgDescriptor.Package, msgDescriptor.Protocol.name, field_desc.name, e.ToString())); } }
public static void ProtoWrite(DataTable table, Stream stream) { using (ProtoWriter writer = new ProtoWriter(stream, null, null)) { if (!string.IsNullOrEmpty(table.TableName)) { ProtoWriter.WriteFieldHeader(1, WireType.String, writer); ProtoWriter.WriteString(table.TableName, writer); } DataColumnCollection columns = table.Columns; Action <object>[] actionArray = new Action <object> [columns.Count]; int index = 0; foreach (DataColumn column in columns) { MappedType boolean; Action <object> action; Action <object> action2 = null; Action <object> action3 = null; Action <object> action4 = null; Action <object> action5 = null; Action <object> action6 = null; Action <object> action7 = null; Action <object> action8 = null; Action <object> action9 = null; Action <object> action10 = null; Action <object> action11 = null; Action <object> action12 = null; ProtoWriter.WriteFieldHeader(2, WireType.StartGroup, writer); SubItemToken token = ProtoWriter.StartSubItem(column, writer); ProtoWriter.WriteFieldHeader(1, WireType.String, writer); ProtoWriter.WriteString(column.ColumnName, writer); ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer); switch (Type.GetTypeCode(column.DataType)) { case TypeCode.Boolean: boolean = MappedType.Boolean; break; case TypeCode.Byte: boolean = MappedType.Byte; break; case TypeCode.Int16: boolean = MappedType.Int16; break; case TypeCode.Int32: boolean = MappedType.Int32; break; case TypeCode.Int64: boolean = MappedType.Int64; break; case TypeCode.Double: boolean = MappedType.Double; break; case TypeCode.Decimal: boolean = MappedType.Decimal; break; case TypeCode.DateTime: boolean = MappedType.DateTime; break; case TypeCode.String: boolean = MappedType.String; break; default: if (column.DataType == typeof(Guid)) { boolean = MappedType.Guid; } else if (column.DataType == typeof(byte[])) { boolean = MappedType.Byte; } else { if (column.DataType != typeof(TimeSpan)) { throw new NotSupportedException(column.DataType.Name); } boolean = MappedType.TimeSpan; } break; } ProtoWriter.WriteInt32((int)boolean, writer); ProtoWriter.WriteFieldHeader(3, WireType.String, writer); ProtoWriter.WriteString(column.Caption, writer); ProtoWriter.EndSubItem(token, writer); int field = index + 1; switch (boolean) { case MappedType.Boolean: if (action2 == null) { action2 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer); ProtoWriter.WriteBoolean(Convert.ToBoolean(value), writer); }; } action = action2; break; case MappedType.Byte: if (action3 == null) { action3 = delegate(object value) { byte[] inArray = value as byte[]; string str = Convert.ToBase64String(inArray); ProtoWriter.WriteFieldHeader(field, WireType.String, writer); ProtoWriter.WriteString(str, writer); }; } action = action3; break; case MappedType.Double: if (action4 == null) { action4 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.Fixed64, writer); ProtoWriter.WriteDouble(Convert.ToDouble(value), writer); }; } action = action4; break; case MappedType.Int16: if (action7 == null) { action7 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer); ProtoWriter.WriteInt16((short)value, writer); }; } action = action7; break; case MappedType.Int32: if (action8 == null) { action8 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer); ProtoWriter.WriteInt32(Convert.ToInt32(value), writer); }; } action = action8; break; case MappedType.Int64: if (action9 == null) { action9 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.Variant, writer); ProtoWriter.WriteInt64((long)value, writer); }; } action = action9; break; case MappedType.String: if (action5 == null) { action5 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.String, writer); ProtoWriter.WriteString(Convert.ToString(value), writer); }; } action = action5; break; case MappedType.Decimal: if (action6 == null) { action6 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer); BclHelpers.WriteDecimal(Convert.ToDecimal(value), writer); }; } action = action6; break; case MappedType.Guid: if (action10 == null) { action10 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer); BclHelpers.WriteGuid((Guid)value, writer); }; } action = action10; break; case MappedType.DateTime: if (action11 == null) { action11 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer); BclHelpers.WriteDateTime(Convert.ToDateTime(value), writer); }; } action = action11; break; case MappedType.TimeSpan: if (action12 == null) { action12 = delegate(object value) { ProtoWriter.WriteFieldHeader(field, WireType.StartGroup, writer); if (value is TimeSpan) { BclHelpers.WriteTimeSpan((TimeSpan)value, writer); } else { BclHelpers.WriteTimeSpan(TimeSpan.Zero, writer); } }; } action = action12; break; default: throw new NotSupportedException(column.DataType.Name); } actionArray[index++] = action; } foreach (DataRow row in table.Rows) { index = 0; ProtoWriter.WriteFieldHeader(3, WireType.StartGroup, writer); SubItemToken token2 = ProtoWriter.StartSubItem(row, writer); foreach (DataColumn column2 in columns) { object obj2 = row[column2]; if ((obj2 != null) && !(obj2 is DBNull)) { actionArray[index](obj2); } index++; } ProtoWriter.EndSubItem(token2, writer); } } }
/// <summary> /// Serialize an <see cref="System.Data.IDataReader"/> to a binary stream using protocol-buffers. /// </summary> /// <param name="stream">The <see cref="System.IO.Stream"/> to write to.</param> /// <param name="reader">The <see cref="System.Data.IDataReader"/>who's contents to serialize.</param> /// <param name="options"><see cref="ProtoDataWriterOptions"/> specifying any custom serialization options.</param> public void Serialize(Stream stream, IDataReader reader, ProtoDataWriterOptions options) { if (stream == null) { throw new ArgumentNullException("stream"); } if (reader == null) { throw new ArgumentNullException("reader"); } // Null options are permitted to be passed in. options = options ?? new ProtoDataWriterOptions(); // For a (minor) performance improvement, Serialize() has been left // as a single long method with functions manually inlined. var resultIndex = 0; using (var writer = new ProtoWriter(stream, null, null)) { do { // This is the underlying protocol buffers structure we use: // // <1 StartGroup> each DataTable // <SubItem> // <2 StartGroup> each DataColumn // <SubItem> // <1 String> Column Name // <2 Variant> Column ProtoDataType (enum casted to int) // </SubItem> // <3 StartGroup> each DataRow // <SubItem> // <(# Column Index) (corresponding type)> Field Value // </SubItem> // </SubItem> // // NB if Field Value is a DataTable, the whole DataTable is // write the table ProtoWriter.WriteFieldHeader(1, WireType.StartGroup, writer); SubItemToken resultToken = ProtoWriter.StartSubItem(resultIndex, writer); var columns = new ProtoDataColumnFactory().GetColumns(reader, options); new HeaderWriter(writer).WriteHeader(columns); var rowWriter = new RowWriter(writer, columns, options); // write the rows while (reader.Read()) { rowWriter.WriteRow(reader); } ProtoWriter.EndSubItem(resultToken, writer); resultIndex++; }while (reader.NextResult()); } }
/// <summary> /// This is the more "complete" version of Serialize, which handles single instances of mapped types. /// The value is written as a complete field, including field-header and (for sub-objects) a /// length-prefix /// In addition to that, this provides support for: /// - basic values; individual int / string / Guid / etc /// - IEnumerable sequences of any type handled by TrySerializeAuxiliaryType /// /// </summary> internal bool TrySerializeAuxiliaryType(ProtoWriter writer, Type type, DataFormat format, int tag, object value) { if (type == null) { type = value.GetType(); } TypeCode typecode = Type.GetTypeCode(type); int modelKey; // note the "ref type" here normalizes against proxies WireType wireType = GetWireType(typecode, format, ref type, out modelKey); if (modelKey >= 0) { // write the header, but defer to the model ProtoWriter.WriteFieldHeader(tag, wireType, writer); switch (wireType) { case WireType.None: throw ProtoWriter.CreateException(writer); case WireType.StartGroup: case WireType.String: // needs a wrapping length etc SubItemToken token = ProtoWriter.StartSubItem(value, writer); Serialize(modelKey, value, writer); ProtoWriter.EndSubItem(token, writer); return(true); default: Serialize(modelKey, value, writer); return(true); } } if (wireType != WireType.None) { ProtoWriter.WriteFieldHeader(tag, wireType, writer); } switch (typecode) { case TypeCode.Int16: ProtoWriter.WriteInt16((short)value, writer); return(true); case TypeCode.Int32: ProtoWriter.WriteInt32((int)value, writer); return(true); case TypeCode.Int64: ProtoWriter.WriteInt64((long)value, writer); return(true); case TypeCode.UInt16: ProtoWriter.WriteUInt16((ushort)value, writer); return(true); case TypeCode.UInt32: ProtoWriter.WriteUInt32((uint)value, writer); return(true); case TypeCode.UInt64: ProtoWriter.WriteUInt64((ulong)value, writer); return(true); case TypeCode.Boolean: ProtoWriter.WriteBoolean((bool)value, writer); return(true); case TypeCode.SByte: ProtoWriter.WriteSByte((sbyte)value, writer); return(true); case TypeCode.Byte: ProtoWriter.WriteByte((byte)value, writer); return(true); case TypeCode.Char: ProtoWriter.WriteUInt16((ushort)(char)value, writer); return(true); case TypeCode.Double: ProtoWriter.WriteDouble((double)value, writer); return(true); case TypeCode.Single: ProtoWriter.WriteSingle((float)value, writer); return(true); case TypeCode.DateTime: BclHelpers.WriteDateTime((DateTime)value, writer); return(true); case TypeCode.Decimal: BclHelpers.WriteDecimal((decimal)value, writer); return(true); case TypeCode.String: ProtoWriter.WriteString((string)value, writer); return(true); } if (type == typeof(byte[])) { ProtoWriter.WriteBytes((byte[])value, writer); return(true); } if (type == typeof(TimeSpan)) { BclHelpers.WriteTimeSpan((TimeSpan)value, writer); return(true); } if (type == typeof(Guid)) { BclHelpers.WriteGuid((Guid)value, writer); return(true); } if (type == typeof(Uri)) { ProtoWriter.WriteString(((Uri)value).AbsoluteUri, writer); return(true); } // by now, we should have covered all the simple cases; if we wrote a field-header, we have // forgotten something! Helpers.DebugAssert(wireType == WireType.None); // now attempt to handle sequences (including arrays and lists) IEnumerable sequence = value as IEnumerable; if (sequence != null) { foreach (object item in sequence) { if (item == null) { throw new NullReferenceException(); } if (!TrySerializeAuxiliaryType(writer, null, format, tag, item)) { ThrowUnexpectedType(item.GetType()); } } return(true); } return(false); }