public void Write(object value, ProtoWriter dest)
{
UnityEngine.GradientColorKey data = (UnityEngine.GradientColorKey)value;
SubItemToken token = ProtoWriter.StartSubItem(value, dest);
ProtoWriter.WriteFieldHeader(1, WireType.Fixed32, dest);
ProtoWriter.WriteSingle(data.time, dest);
ProtoWriter.WriteFieldHeader(2, WireType.String, dest);
this.colorSerializer.Write(data.color, dest);
ProtoWriter.EndSubItem(token, dest);
}
public void Write(object value, ProtoWriter dest)
{
UnityEngine.GradientAlphaKey data = (UnityEngine.GradientAlphaKey)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.alpha, dest);
ProtoWriter.EndSubItem(token, dest);
}
public void Write(object value, ProtoWriter dest)
{
UnityEngine.Vector2 data = (UnityEngine.Vector2)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.EndSubItem(token, dest);
}
public void Write(object value, ProtoWriter dest)
{
UnityEngine.Color data = (UnityEngine.Color)value;
SubItemToken token = ProtoWriter.StartSubItem(value, dest);
ProtoWriter.WriteFieldHeader(1, WireType.Fixed32, dest);
ProtoWriter.WriteSingle(data.r, dest);
ProtoWriter.WriteFieldHeader(2, WireType.Fixed32, dest);
ProtoWriter.WriteSingle(data.g, dest);
ProtoWriter.WriteFieldHeader(3, WireType.Fixed32, dest);
ProtoWriter.WriteSingle(data.b, dest);
ProtoWriter.WriteFieldHeader(4, WireType.Fixed32, dest);
ProtoWriter.WriteSingle(data.a, dest);
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 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();
}
/// <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);
}
public void Write(object value, ProtoWriter dest)
{
ProtoWriter.WriteSingle(ValueObject.Value <float>(value), 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()));
}
}
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);
}
}
}
public void Write(ProtoWriter dest, ref ProtoWriter.State state, object value)
{
ProtoWriter.WriteSingle((float)value, dest, ref state);
}
private void WriteColumn(ProtoWriter writer, IReactiveColumn column, int fieldId, int rowId)
{
if (column.Type == typeof(int))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt32(_table.GetValue <int>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(short))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt16(_table.GetValue <short>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(string))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.String, writer);
var value = _table.GetValue <string>(column.ColumnId, rowId);
// Console.WriteLine("Writing string {0}", value);
ProtoWriter.WriteString(value ?? string.Empty, writer);
}
else if (column.Type == typeof(bool))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteBoolean(_table.GetValue <bool>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(double))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Fixed64, writer);
ProtoWriter.WriteDouble(_table.GetValue <double>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(long))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt64(_table.GetValue <long>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(decimal))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteDecimal(_table.GetValue <decimal>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(DateTime))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteDateTime(_table.GetValue <DateTime>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(TimeSpan))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteTimeSpan(_table.GetValue <TimeSpan>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(Guid))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.StartGroup, writer);
BclHelpers.WriteGuid(_table.GetValue <Guid>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(float))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Fixed32, writer);
ProtoWriter.WriteSingle(_table.GetValue <float>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(byte))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteByte(_table.GetValue <byte>(column.ColumnId, rowId), writer);
}
else if (column.Type == typeof(char))
{
ProtoWriter.WriteFieldHeader(fieldId, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)_table.GetValue <char>(column.ColumnId, rowId), writer);
}
}
private static void WriteRecord(IDataReader reader, List <ProtoBufDataColumn> columns, ProtoWriter writer, int recordIndex)
{
ProtoWriter.WriteFieldHeader(FieldHeaders.Record, WireType.StartGroup, writer);
var recordToken = ProtoWriter.StartSubItem(recordIndex, writer);
for (var i = 0; i < columns.Count; i++)
{
var fieldHeader = i + 1;
if (!reader.IsDBNull(columns[i].Ordinal))
{
switch (columns[i].ProtoBufDataType)
{
case ProtoBufDataType.Bool:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteBoolean(reader.GetBoolean(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Byte:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteByte(reader.GetByte(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.ByteArray:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.String, writer);
var value = reader[columns[i].Ordinal];
ProtoWriter.WriteBytes((byte[])value, 0, ((byte[])value).Length, writer);
break;
case ProtoBufDataType.Char:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)reader.GetChar(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.CharArray:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.String, writer);
ProtoWriter.WriteString(new string((char[])reader[columns[i].Ordinal]), writer);
break;
case ProtoBufDataType.DateTime:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteDateTime(reader.GetDateTime(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Decimal:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteDecimal(reader.GetDecimal(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Double:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Fixed64, writer);
ProtoWriter.WriteDouble(reader.GetDouble(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Float:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Fixed32, writer);
ProtoWriter.WriteSingle(reader.GetFloat(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Guid:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteGuid(reader.GetGuid(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Int:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt32(reader.GetInt32(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Long:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt64(reader.GetInt64(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.Short:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.Variant, writer);
ProtoWriter.WriteInt16(reader.GetInt16(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.String:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.String, writer);
ProtoWriter.WriteString(reader.GetString(columns[i].Ordinal), writer);
break;
case ProtoBufDataType.TimeSpan:
ProtoWriter.WriteFieldHeader(fieldHeader, WireType.StartGroup, writer);
BclHelpers.WriteTimeSpan((TimeSpan)reader[columns[i].Ordinal], writer);
break;
}
}
}
ProtoWriter.EndSubItem(recordToken, writer);
}
void WriteField(ProtoWriter writer, object memberV, Type memberT, int fieldNumber)
{
if (memberT == typeof(int))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteInt32((int)memberV, writer);
}
else if (memberT == typeof(uint))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteUInt32((uint)memberV, writer);
}
else if (memberT == typeof(bool))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteBoolean((bool)memberV, writer);
}
else if (memberT == typeof(byte))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteByte((byte)memberV, writer);
}
else if (memberT == typeof(sbyte))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteSByte((sbyte)memberV, writer);
}
else if (memberT == typeof(float))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteSingle((float)memberV, writer);
}
else if (memberT == typeof(double))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteDouble((double)memberV, writer);
}
else if (memberT == typeof(short))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)memberV, writer);
}
else if (memberT == typeof(ushort))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteUInt16((ushort)memberV, writer);
}
else if (memberT == typeof(long))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteInt64((long)memberV, writer);
}
else if (memberT == typeof(ulong))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, writer);
ProtoWriter.WriteUInt64((ulong)memberV, writer);
}
else if (memberT == typeof(string))
{
string str = (string)memberV;
if (!string.IsNullOrEmpty(str))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, writer);
ProtoWriter.WriteString(str, writer);
}
}
else if (memberT == typeof(byte[]))
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, writer);
ProtoWriter.WriteBytes((byte[])memberV, writer);
}
else if (memberT == typeof(SInstance))
{
SInstance subSinstance = (SInstance)memberV;
if (subSinstance != null)
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, writer);
SubItemToken st = ProtoWriter.StartSubItem(null, writer);
WriteSInstance(writer, subSinstance);
ProtoWriter.EndSubItem(st, writer);
}
}
else
{
throw new NotImplementedException("未实现类型: " + memberT);
}
}
public void Write(object value, ProtoWriter dest)
{
ProtoWriter.WriteSingle((float)value, dest);
}
public void WriteRow(IDataRecord row)
{
int fieldIndex = 1;
ProtoWriter.WriteFieldHeader(3, WireType.StartGroup, writer);
SubItemToken token = ProtoWriter.StartSubItem(rowIndex, writer);
foreach (ProtoDataColumn column in columns)
{
object value = row[column.ColumnIndex];
if (value == null || value is DBNull || (options.SerializeEmptyArraysAsNull && IsZeroLengthArray(value)))
{
// don't write anything
}
else
{
switch (column.ProtoDataType)
{
case ProtoDataType.String:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.String, writer);
ProtoWriter.WriteString((string)value, writer);
break;
case ProtoDataType.Short:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)value, writer);
break;
case ProtoDataType.Decimal:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteDecimal((decimal)value, writer);
break;
case ProtoDataType.Int:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt32((int)value, writer);
break;
case ProtoDataType.Guid:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteGuid((Guid)value, writer);
break;
case ProtoDataType.DateTime:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteDateTime((DateTime)value, writer);
break;
case ProtoDataType.Bool:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteBoolean((bool)value, writer);
break;
case ProtoDataType.Byte:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteByte((byte)value, writer);
break;
case ProtoDataType.Char:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt16((short)(char)value, writer);
break;
case ProtoDataType.Double:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Fixed64, writer);
ProtoWriter.WriteDouble((double)value, writer);
break;
case ProtoDataType.Float:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Fixed32, writer);
ProtoWriter.WriteSingle((float)value, writer);
break;
case ProtoDataType.Long:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.Variant, writer);
ProtoWriter.WriteInt64((long)value, writer);
break;
case ProtoDataType.ByteArray:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.String, writer);
ProtoWriter.WriteBytes((byte[])value, 0, ((byte[])value).Length, writer);
break;
case ProtoDataType.CharArray:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.String, writer);
ProtoWriter.WriteString(new string((char[])value), writer);
break;
case ProtoDataType.TimeSpan:
ProtoWriter.WriteFieldHeader(fieldIndex, WireType.StartGroup, writer);
BclHelpers.WriteTimeSpan((TimeSpan)value, writer);
break;
default:
throw new UnsupportedColumnTypeException(
ConvertProtoDataType.ToClrType(column.ProtoDataType));
}
}
fieldIndex++;
}
ProtoWriter.EndSubItem(token, writer);
rowIndex++;
}
