public void ShouldThrowExceptionOnColumnTypeInvalidFieldHeader()
{
// Arrange
var stream = new MemoryStream();
using (var writer = new ProtoWriter(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(42, WireType.Variant, writer);
ProtoWriter.WriteInt32((int)1, writer);
ProtoWriter.EndSubItem(columnToken, writer);
ProtoWriter.EndSubItem(resultToken, writer);
}
stream.Position = 0;
// Assert
Assert.Throws <InvalidDataException>(() => new ProtoDataReader(stream));
}
public override void Write(object value, ProtoWriter dest)
{
Action metaWriter =
() =>
{
// we still write length in case it will be read as array
int length = (value as ICollection)?.Count ?? 0;
if (length > 0)
{
ProtoWriter.WriteFieldHeader(ListHelpers.FieldLength, WireType.Variant, dest);
ProtoWriter.WriteInt32(length, dest);
}
if (_writeSubType)
{
Type t = value.GetType();
if (_concreteTypeDefault != t)
{
ProtoWriter.WriteFieldHeaderBegin(ListHelpers.FieldSubtype, dest);
_subTypeHelpers.Write(_metaType, t, dest);
}
}
};
ListHelpers.Write(value, metaWriter, null, dest);
}
public void ShouldAcceptTrailingFieldHeaders()
{
// Arrange
var stream = new MemoryStream();
using (var writer = new ProtoWriter(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)1, writer);
ProtoWriter.WriteFieldHeader(42, WireType.String, writer);
ProtoWriter.WriteString("bar", writer);
ProtoWriter.EndSubItem(columnToken, writer);
ProtoWriter.EndSubItem(resultToken, writer);
}
stream.Position = 0;
// Assert
new ProtoDataReader(stream);
}
public void CanWriteMessageSetData()
{
using (var ms = new MemoryStream())
{
using (var writer = new ProtoWriter(ms, null, null))
{
ProtoWriter.WriteFieldHeader(5, WireType.String, writer);
var tok = ProtoWriter.StartSubItem(null, writer);
ProtoWriter.WriteFieldHeader(1, WireType.StartGroup, writer);
var tok2 = ProtoWriter.StartSubItem(null, writer);
ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer);
ProtoWriter.WriteInt32(15447542, writer);
ProtoWriter.WriteFieldHeader(3, WireType.String, writer);
var tok3 = ProtoWriter.StartSubItem(null, writer);
ProtoWriter.WriteFieldHeader(1, WireType.String, writer);
ProtoWriter.WriteString("EmbeddedMessageSetElement", writer);
ProtoWriter.EndSubItem(tok3, writer);
ProtoWriter.EndSubItem(tok2, writer);
ProtoWriter.EndSubItem(tok, writer);
}
var hex = BitConverter.ToString(ms.ToArray(), 0, (int)ms.Length);
Assert.Equal("2A-24-0B-10-F6-EB-AE-07-1A-1B-0A-19"
+ "-45-6D-62-65-64-64-65-64-4D-65-73-73-61-67-65-53"
+ "-65-74-45-6C-65-6D-65-6E-74-0C", hex);
}
}
public void Write(object value, ProtoWriter dest)
{
if (map == null)
{
#if TTD_LONGENUMS
ProtoWriter.WriteInt64(EnumToWire(value), dest);
#else
ProtoWriter.WriteInt32(EnumToWire(value), dest);
#endif
}
else
{
for (int i = 0; i < map.Length; i++)
{
if (object.Equals(map[i].TypedValue, value))
{
#if TTD_LONGENUMS
ProtoWriter.WriteInt64(map[i].WireValue, dest);
#else
ProtoWriter.WriteInt32(map[i].WireValue, dest);
#endif
return;
}
}
ProtoWriter.ThrowEnumException(dest, value);
}
}
private void WriteRowId(ProtoWriter writer, TableUpdate value, int operationType)
{
ProtoWriter.WriteFieldHeader(operationType, WireType.StartGroup, writer);
var token = ProtoWriter.StartSubItem(value.RowIndex, writer);
ProtoWriter.WriteFieldHeader(ProtobufFieldIds.RowId, WireType.Variant, writer);
ProtoWriter.WriteInt32(value.RowIndex, writer);
ProtoWriter.EndSubItem(token, writer);
}
public override void Write(object value, ProtoWriter dest)
{
_listHelpers.Write(value,
() =>
{
int length = ((Array)value).Length;
if (length > 0)
{
ProtoWriter.WriteFieldHeader(ListHelpers.FieldLength, WireType.Variant, dest);
ProtoWriter.WriteInt32(length, dest);
}
}, null, dest);
}
public override void Write(object value, ProtoWriter dest)
{
_listHelpers.Write(value,
() =>
{
var arr = (Array)value;
for (int i = 0; i < _rank; i++)
{
ProtoWriter.WriteFieldHeader(ListHelpers.FieldLength, WireType.Variant, dest);
ProtoWriter.WriteInt32(arr.GetLength(i), dest);
}
}, null, dest);
}
private static SubItemToken WriteStartUpdate(ProtoWriter writer, int rowIndex, out int rowId)
{
// Start the row group
ProtoWriter.WriteFieldHeader(ProtobufOperationTypes.Update, WireType.StartGroup, writer);
var token = ProtoWriter.StartSubItem(rowIndex, writer);
rowId = rowIndex;
// Send the row id so that it can be matched against the local row id at the other end.
ProtoWriter.WriteFieldHeader(ProtobufFieldIds.RowId, WireType.Variant, writer);
ProtoWriter.WriteInt32(rowId, writer);
return(token);
}
public void Write(object value, ProtoWriter dest)
{
UnityEngine.LayerMask data = (UnityEngine.LayerMask)value;
SubItemToken token = ProtoWriter.StartSubItem(value, dest);
ProtoWriter.WriteFieldHeader(1, WireType.Variant, dest);
ProtoWriter.WriteInt32(data.value, dest);
ProtoWriter.EndSubItem(token, dest);
}
private static void WriteColumn(ProtoWriter writer, ProtoBufDataColumn column)
{
ProtoWriter.WriteFieldHeader(FieldHeaders.Column, WireType.StartGroup, writer);
var columnToken = ProtoWriter.StartSubItem(column, writer);
ProtoWriter.WriteFieldHeader(FieldHeaders.ColumnName, WireType.String, writer);
ProtoWriter.WriteString(column.Name, writer);
ProtoWriter.WriteFieldHeader(FieldHeaders.ColumnType, WireType.Variant, writer);
ProtoWriter.WriteInt32((int)column.ProtoBufDataType, writer);
ProtoWriter.EndSubItem(columnToken, writer);
}
public void Write(object value, ProtoWriter dest)
{
if (map == null)
{
ProtoWriter.WriteInt32(EnumToWire(value), dest);
return;
}
for (int i = 0; i < map.Length; i++)
{
if (object.Equals(map[i].TypedValue, value))
{
ProtoWriter.WriteInt32(map[i].WireValue, dest);
return;
}
}
ProtoWriter.ThrowEnumException(dest, value);
}
public void TestVariantInt32()
{
for (int i = 0; i < 128; i++)
{
Util.Test(pw =>
{
ProtoWriter.WriteFieldHeader(1, WireType.Variant, pw);
ProtoWriter.WriteInt32(i, pw);
}, "08" // 1 * 8 + 0
+ i.ToString("X2")
);
}
Util.Test(pw => {
ProtoWriter.WriteFieldHeader(1, WireType.Variant, pw);
ProtoWriter.WriteInt32(128, pw);
}, "088001");
}
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);
}
}
/// <summary>
/// 获取数据
/// </summary>
/// <param name="value">值</param>
/// <param name="order">序号</param>
/// <returns></returns>
public static byte[] GetData(int value, int order)
{
using (var ms = new MemoryStream())
{
var writer = ProtoWriter.Create(ms, _typeModel);
// 写入数据
ProtoWriter.WriteFieldHeader(order, WireType.Variant, writer);
ProtoWriter.WriteInt32(value, writer);
// 释放缓冲区
writer.Close();
ms.Position = 0;
var data = ms.ToArray();
return(data);
}
}
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 writeSingle(float value, WireType wireType)
{
switch (wireType)
{
case WireType.Fixed32:
#if FEAT_SAFE
ProtoWriter.WriteInt32(BitConverter.ToInt32(BitConverter.GetBytes(value), 0), writer);
#else
writeInt32(*(int *)&value, wireType);
#endif
return;
case WireType.Fixed64:
writeDouble((double)value, wireType);
return;
default:
throw createException(wireType);
}
}
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)
{
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)
{
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);
}
/// <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()));
}
}
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);
}
}
}
public static void WriteRecord(ProtoWriterContext context, int recordIndex, IDataRecord record)
{
ProtoWriter.WriteFieldHeader(RecordFieldHeader, WireType.StartGroup, context.Writer);
context.StartSubItem(recordIndex);
for (var columnIndex = 0; columnIndex < context.Columns.Count; columnIndex++)
{
// The check whether record[columnIndex] == null is removed due to the fact that value types have to be
// boxed into an object just to check whether the field value is null. This creates garbage, thus has
// impact on garbage collection. Removing the check should not be a problem as IDataRecord.IsDBNull
// should be sufficient (tested with SqlDataReader, SqlLiteDataReader, and DataTableReader).
if (record.IsDBNull(columnIndex))
{
continue;
}
var fieldNumber = columnIndex + 1;
switch (context.Columns[columnIndex].ProtoDataType)
{
case ProtoDataType.String:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, context.Writer);
ProtoWriter.WriteString(record.GetString(columnIndex), context.Writer);
break;
case ProtoDataType.Short:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt16(record.GetInt16(columnIndex), context.Writer);
break;
case ProtoDataType.Decimal:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteDecimal(record.GetDecimal(columnIndex), context.Writer);
break;
case ProtoDataType.Int:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt32(record.GetInt32(columnIndex), context.Writer);
break;
case ProtoDataType.Guid:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteGuid(record.GetGuid(columnIndex), context.Writer);
break;
case ProtoDataType.DateTime:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteDateTime(record.GetDateTime(columnIndex), context.Writer);
break;
case ProtoDataType.Bool:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteBoolean(record.GetBoolean(columnIndex), context.Writer);
break;
case ProtoDataType.Byte:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteByte(record.GetByte(columnIndex), context.Writer);
break;
case ProtoDataType.Char:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt16((short)record.GetChar(columnIndex), context.Writer);
break;
case ProtoDataType.Double:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Fixed64, context.Writer);
ProtoWriter.WriteDouble(record.GetDouble(columnIndex), context.Writer);
break;
case ProtoDataType.Float:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Fixed32, context.Writer);
ProtoWriter.WriteSingle(record.GetFloat(columnIndex), context.Writer);
break;
case ProtoDataType.Long:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, context.Writer);
ProtoWriter.WriteInt64(record.GetInt64(columnIndex), context.Writer);
break;
case ProtoDataType.ByteArray:
var bytes = (byte[])record[columnIndex];
if (bytes.Length != 0 || !context.Options.SerializeEmptyArraysAsNull)
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, context.Writer);
ProtoWriter.WriteBytes(bytes, 0, bytes.Length, context.Writer);
}
break;
case ProtoDataType.CharArray:
var characters = (char[])record[columnIndex];
if (characters.Length != 0 || !context.Options.SerializeEmptyArraysAsNull)
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, context.Writer);
ProtoWriter.WriteString(new string(characters), context.Writer);
}
break;
case ProtoDataType.TimeSpan:
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.StartGroup, context.Writer);
BclHelpers.WriteTimeSpan((TimeSpan)record[columnIndex], context.Writer);
break;
default:
throw new NotSupportedException($"The data type '{context.Columns[columnIndex].DataType.Name}' is not supported. The supported data types are: {TypeHelper.GetSupportedDataTypes()}.");
}
}
context.EndSubItem();
}
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>
/// The write.
/// </summary>
/// <param name="targetPlatform">
/// The target platform.
/// </param>
/// <param name="writer">
/// The writer.
/// </param>
private static void Write(TargetPlatform targetPlatform, ProtoWriter writer)
{
ProtoWriter.WriteFieldHeader(1, WireType.Variant, writer);
if (targetPlatform != TargetPlatform.Windows)
{
if (targetPlatform != TargetPlatform.Xbox360)
{
if (targetPlatform != TargetPlatform.WindowsPhone)
{
if (targetPlatform != TargetPlatform.iOS)
{
if (targetPlatform != TargetPlatform.Android)
{
if (targetPlatform != TargetPlatform.Linux)
{
if (targetPlatform != TargetPlatform.MacOSX)
{
if (targetPlatform != TargetPlatform.WindowsStoreApp)
{
if (targetPlatform != TargetPlatform.NativeClient)
{
if (targetPlatform != TargetPlatform.Ouya)
{
if (targetPlatform != TargetPlatform.PlayStationMobile)
{
if (targetPlatform != TargetPlatform.WindowsPhone8)
{
if (targetPlatform != TargetPlatform.RaspberryPi)
{
ProtoWriter.ThrowEnumException(writer, targetPlatform);
}
else
{
ProtoWriter.WriteInt32(12, writer);
}
}
else
{
ProtoWriter.WriteInt32(11, writer);
}
}
else
{
ProtoWriter.WriteInt32(10, writer);
}
}
else
{
ProtoWriter.WriteInt32(9, writer);
}
}
else
{
ProtoWriter.WriteInt32(8, writer);
}
}
else
{
ProtoWriter.WriteInt32(7, writer);
}
}
else
{
ProtoWriter.WriteInt32(6, writer);
}
}
else
{
ProtoWriter.WriteInt32(5, writer);
}
}
else
{
ProtoWriter.WriteInt32(4, writer);
}
}
else
{
ProtoWriter.WriteInt32(3, writer);
}
}
else
{
ProtoWriter.WriteInt32(2, writer);
}
}
else
{
ProtoWriter.WriteInt32(1, writer);
}
}
else
{
ProtoWriter.WriteInt32(0, writer);
}
}
/// <summary>
/// The write.
/// </summary>
/// <param name="platformData">
/// The platform data.
/// </param>
/// <param name="writer">
/// The writer.
/// </param>
private static void Write(PlatformData platformData, ProtoWriter writer)
{
if (platformData.GetType() != typeof(PlatformData))
{
ThrowUnexpectedSubtype(typeof(PlatformData), platformData.GetType());
}
TargetPlatform expr_2D = platformData.Platform;
if (expr_2D != TargetPlatform.Windows)
{
ProtoWriter.WriteFieldHeader(1, WireType.Variant, writer);
TargetPlatform targetPlatform = expr_2D;
if (targetPlatform != TargetPlatform.Windows)
{
if (targetPlatform != TargetPlatform.Xbox360)
{
if (targetPlatform != TargetPlatform.WindowsPhone)
{
if (targetPlatform != TargetPlatform.iOS)
{
if (targetPlatform != TargetPlatform.Android)
{
if (targetPlatform != TargetPlatform.Linux)
{
if (targetPlatform != TargetPlatform.MacOSX)
{
if (targetPlatform != TargetPlatform.WindowsStoreApp)
{
if (targetPlatform != TargetPlatform.NativeClient)
{
if (targetPlatform != TargetPlatform.Ouya)
{
if (targetPlatform != TargetPlatform.PlayStationMobile)
{
if (targetPlatform != TargetPlatform.WindowsPhone8)
{
if (targetPlatform != TargetPlatform.RaspberryPi)
{
ProtoWriter.ThrowEnumException(
writer,
targetPlatform);
}
else
{
ProtoWriter.WriteInt32(12, writer);
}
}
else
{
ProtoWriter.WriteInt32(11, writer);
}
}
else
{
ProtoWriter.WriteInt32(10, writer);
}
}
else
{
ProtoWriter.WriteInt32(9, writer);
}
}
else
{
ProtoWriter.WriteInt32(8, writer);
}
}
else
{
ProtoWriter.WriteInt32(7, writer);
}
}
else
{
ProtoWriter.WriteInt32(6, writer);
}
}
else
{
ProtoWriter.WriteInt32(5, writer);
}
}
else
{
ProtoWriter.WriteInt32(4, writer);
}
}
else
{
ProtoWriter.WriteInt32(3, writer);
}
}
else
{
ProtoWriter.WriteInt32(2, writer);
}
}
else
{
ProtoWriter.WriteInt32(1, writer);
}
}
else
{
ProtoWriter.WriteInt32(0, writer);
}
}
byte[] expr_143 = platformData.Data;
if (expr_143 != null)
{
ProtoWriter.WriteFieldHeader(2, WireType.String, writer);
ProtoWriter.WriteBytes(expr_143, writer);
}
}
private static void WriteTimeSpanImpl(TimeSpan timeSpan, ProtoWriter dest, DateTimeKind kind)
{
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
switch (dest.WireType)
{
case WireType.String:
case WireType.StartGroup:
TimeSpanScale scale;
long value = timeSpan.Ticks;
if (timeSpan == TimeSpan.MaxValue)
{
value = 1;
scale = TimeSpanScale.MinMax;
}
else if (timeSpan == TimeSpan.MinValue)
{
value = -1;
scale = TimeSpanScale.MinMax;
}
else if (value % TimeSpan.TicksPerDay == 0)
{
scale = TimeSpanScale.Days;
value /= TimeSpan.TicksPerDay;
}
else if (value % TimeSpan.TicksPerHour == 0)
{
scale = TimeSpanScale.Hours;
value /= TimeSpan.TicksPerHour;
}
else if (value % TimeSpan.TicksPerMinute == 0)
{
scale = TimeSpanScale.Minutes;
value /= TimeSpan.TicksPerMinute;
}
else if (value % TimeSpan.TicksPerSecond == 0)
{
scale = TimeSpanScale.Seconds;
value /= TimeSpan.TicksPerSecond;
}
else if (value % TimeSpan.TicksPerMillisecond == 0)
{
scale = TimeSpanScale.Milliseconds;
value /= TimeSpan.TicksPerMillisecond;
}
else
{
scale = TimeSpanScale.Ticks;
}
SubItemToken token = ProtoWriter.StartSubItemWithoutWritingHeader(null, dest);
if (value != 0)
{
ProtoWriter.WriteFieldHeader(FieldTimeSpanValue, WireType.SignedVariant, dest);
ProtoWriter.WriteInt64(value, dest);
}
if (scale != TimeSpanScale.Days)
{
ProtoWriter.WriteFieldHeader(FieldTimeSpanScale, WireType.Variant, dest);
ProtoWriter.WriteInt32((int)scale, dest);
}
if (kind != DateTimeKind.Unspecified)
{
ProtoWriter.WriteFieldHeader(FieldTimeSpanKind, WireType.Variant, dest);
ProtoWriter.WriteInt32((int)kind, dest);
}
ProtoWriter.EndSubItem(token, dest);
break;
case WireType.Fixed64:
ProtoWriter.WriteInt64(timeSpan.Ticks, dest);
break;
default:
throw new ProtoException("Unexpected wire-type: " + dest.WireType.ToString());
}
}
static void Main(string[] args)
{
Console.WriteLine($"Begin");
Console.WriteLine();
byte[] data;
ValueDemo model;
byte[] data1;
MemoryStream ms;
ProtoWriter writestate;
var typeModel = RuntimeTypeModel.Create();
// Bool
ms = new MemoryStream();
writestate = ProtoBuf.ProtoWriter.Create(ms, typeModel);
ProtoWriter.WriteFieldHeader(3, WireType.Variant, writestate);
ProtoWriter.WriteBoolean(true, writestate);
writestate.Close();
ms.Position = 0;
data = ms.ToArray();
model = new ValueDemo {
Success = true
};
data1 = ProtoBufSerializer.Serialize(model);
ms.Close();
ms = null;
Print("bool");
// Int32
ms = new MemoryStream();
writestate = ProtoBuf.ProtoWriter.Create(ms, typeModel);
ProtoWriter.WriteFieldHeader(5, WireType.Variant, writestate);
ProtoWriter.WriteInt32(500, writestate);
writestate.Close();
ms.Position = 0;
data = ms.ToArray();
model = new ValueDemo {
Value = 500
};
data1 = ProtoBufSerializer.Serialize(model);
ms.Close();
ms = null;
Print("int32");
// Uint32
ms = new MemoryStream();
writestate = ProtoBuf.ProtoWriter.Create(ms, typeModel);
ProtoWriter.WriteFieldHeader(4, WireType.Variant, writestate);
ProtoWriter.WriteUInt32(UInt32.MaxValue, writestate);
writestate.Close();
ms.Position = 0;
data = ms.ToArray();
model = new ValueDemo {
Values = UInt32.MaxValue
};
data1 = ProtoBufSerializer.Serialize(model);
ms.Close();
ms = null;
Print("uint32");
Console.WriteLine();
Console.WriteLine($"End");
// Int32
void Print(string s)
{
Console.WriteLine($"{s} - wri: {BitConverter.ToString(data)}");
Console.WriteLine($"{s} - ser: {BitConverter.ToString(data1)}");
}
}
// Token: 0x06003582 RID: 13698 RVA: 0x00134A7B File Offset: 0x00132E7B
public void Write(object value, ProtoWriter dest)
{
ProtoWriter.WriteInt32((int)value, dest);
}
/// <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);
}
