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