// Token: 0x0600022A RID: 554 RVA: 0x0000EFAC File Offset: 0x0000D1AC
public override object Read(object value, ProtoReader source)
{
SubItemToken token = ProtoReader.StartSubItem(source);
int num;
while ((num = source.ReadFieldHeader()) > 0)
{
if (num == 1)
{
value = this.Tail.Read(value, source);
}
else
{
source.SkipField();
}
}
ProtoReader.EndSubItem(token, source);
return(value);
}
public override object Read(object value, ProtoReader source)
{
SubItemToken tok = ProtoReader.StartSubItem(source);
int field;
while ((field = source.ReadFieldHeader()) > 0)
{
if (field == Tag)
{
value = Tail.Read(value, source);
}
else
{
source.SkipField();
}
}
ProtoReader.EndSubItem(tok, source);
return(value);
}
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 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, writer);
SubItemToken columnToken = ProtoWriter.StartSubItem(column, writer);
ProtoWriter.WriteFieldHeader(1, WireType.String, writer);
ProtoWriter.WriteString(column.ColumnName, writer);
ProtoWriter.WriteFieldHeader(2, WireType.Variant, writer);
ProtoWriter.WriteInt32((int)column.ProtoDataType, writer);
ProtoWriter.EndSubItem(columnToken, writer);
}
}
public override object Read(object value, ProtoReader source)
{
object obj = this.builderFactory.Invoke(null, null);
int fieldNumber = source.FieldNumber;
object[] objArray = new object[1];
if (base.AppendToCollection && value != null && ((IList)value).Count != 0)
{
if (this.addRange == null)
{
foreach (object obj1 in (IList)value)
{
objArray[0] = obj1;
[email protected](obj, objArray);
}
}
else
{
objArray[0] = value;
this.addRange.Invoke(obj, objArray);
}
}
if (this.packedWireType == WireType.None || source.WireType != WireType.String)
{
do
{
objArray[0] = this.Tail.Read(null, source);
[email protected](obj, objArray);
}while (source.TryReadFieldHeader(fieldNumber));
}
else
{
SubItemToken subItemToken = ProtoReader.StartSubItem(source);
while (ProtoReader.HasSubValue(this.packedWireType, source))
{
objArray[0] = this.Tail.Read(null, source);
[email protected](obj, objArray);
}
ProtoReader.EndSubItem(subItemToken, source);
}
return(this.finish.Invoke(obj, null));
}
public object Read(object value, ProtoReader source)
{
UnityEngine.Keyframe data = (UnityEngine.Keyframe)value;
int fieldNumber = 0;
SubItemToken token = ProtoReader.StartSubItem(source);
while ((fieldNumber = source.ReadFieldHeader()) != 0)
{
switch (fieldNumber)
{
case 1:
data.time = source.ReadSingle();
break;
case 2:
data.value = source.ReadSingle();
break;
case 3:
data.inTangent = source.ReadSingle();
break;
case 4:
data.outTangent = source.ReadSingle();
break;
case 5:
data.tangentMode = source.ReadInt32();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
return(data);
}
public static DataSet ProtoRead(Stream stream)
{
DataSet ds = new DataSet();
using (ProtoReader reader = new ProtoReader(stream, null, null))
{
int num;
while ((num = reader.ReadFieldHeader()) != 0)
{
if (num <= 0)
{
continue;
}
switch (num)
{
case 1:
{
SubItemToken token = ProtoReader.StartSubItem(reader);
ProtoReadTable(ds, reader);
ProtoReader.EndSubItem(token, reader);
continue;
}
case 3:
{
ds.DataSetName = reader.ReadString();
continue;
}
case 4:
{
string s = reader.ReadString();
MemoryStream stream2 = new MemoryStream(Encoding.UTF8.GetBytes(s));
ds.ReadXmlSchema(stream2);
continue;
}
}
reader.SkipField();
}
}
return(ds);
}
public override object Read(object value, ProtoReader source)
{
object obj = builderFactory.Invoke(null, null);
int fieldNumber = source.FieldNumber;
object[] array = new object[1];
if (base.AppendToCollection && value != null && ((IList)value).Count != 0)
{
if (addRange != null)
{
array[0] = value;
addRange.Invoke(obj, array);
}
else
{
foreach (object item in (IList)value)
{
object obj2 = array[0] = item;
add.Invoke(obj, array);
}
}
}
if (packedWireType != WireType.None && source.WireType == WireType.String)
{
SubItemToken token = ProtoReader.StartSubItem(source);
while (ProtoReader.HasSubValue(packedWireType, source))
{
array[0] = Tail.Read(null, source);
add.Invoke(obj, array);
}
ProtoReader.EndSubItem(token, source);
}
else
{
do
{
array[0] = Tail.Read(null, source);
add.Invoke(obj, array);
}while (source.TryReadFieldHeader(fieldNumber));
}
return(finish.Invoke(obj, null));
}
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);
}
}
private static SubItemToken StartSubItem(object instance, ProtoWriter writer, bool allowFixed)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (++writer.depth > 25)
{
writer.CheckRecursionStackAndPush(instance);
}
if (writer.packedFieldNumber != 0)
{
throw new InvalidOperationException("Cannot begin a sub-item while performing packed encoding");
}
switch (writer.wireType)
{
case WireType.String:
writer.wireType = WireType.None;
ProtoWriter.DemandSpace(32, writer);
writer.flushLock++;
writer.position++;
return(new SubItemToken(writer.ioIndex++));
case WireType.StartGroup:
writer.wireType = WireType.None;
return(new SubItemToken(-writer.fieldNumber));
case WireType.Fixed32:
{
if (!allowFixed)
{
throw ProtoWriter.CreateException(writer);
}
ProtoWriter.DemandSpace(32, writer);
writer.flushLock++;
SubItemToken token = new SubItemToken(writer.ioIndex);
ProtoWriter.IncrementedAndReset(4, writer);
return(token);
}
}
throw ProtoWriter.CreateException(writer);
}
public void Write(object value, ProtoWriter dest)
{
UnityEngine.Vector4 data = (UnityEngine.Vector4)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.WriteFieldHeader(4, WireType.Fixed32, dest);
ProtoWriter.WriteSingle(data.w, dest);
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 object Read(object value, ProtoReader source)
{
UnityEngine.AnimationCurve data = (UnityEngine.AnimationCurve)
(value == null ? CreateInstance(source) : value);
int fieldNumber = 0;
SubItemToken token = ProtoReader.StartSubItem(source);
while ((fieldNumber = source.ReadFieldHeader()) != 0)
{
switch (fieldNumber)
{
case 1:
data.preWrapMode = (UnityEngine.WrapMode)source.ReadInt32();
break;
case 2:
data.postWrapMode = (UnityEngine.WrapMode)source.ReadInt32();
break;
case 3:
keys.Clear();
do
{
keys.Add((UnityEngine.Keyframe) this.keyframeSerializer.Read(
new UnityEngine.Keyframe(), source));
} while (source.TryReadFieldHeader(3));
data.keys = keys.ToArray();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
return(data);
}
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 override object Read(object untyped, ProtoReader source)
{
TDictionary typed = AppendToCollection ? ((TDictionary)untyped) : null;
//if (typed == null) typed = (TDictionary)Activator.CreateInstance(concreteType);
if (typed == null)
{
typed = (TDictionary)ActivatorUtils.FastCreateInstance(concreteType);
}
do
{
var key = DefaultKey;
var value = DefaultValue;
SubItemToken token = ProtoReader.StartSubItem(source);
int field;
while ((field = source.ReadFieldHeader()) > 0)
{
switch (field)
{
case 1:
key = (TKey)keyTail.Read(null, source);
break;
case 2:
value = (TValue)Tail.Read(Tail.RequiresOldValue ? (object)value : null, source);
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
typed[key] = value;
} while (source.TryReadFieldHeader(fieldNumber));
return(typed);
}
public override object Read(object value, ProtoReader source)
{
int num;
int fieldNumber = source.FieldNumber;
BasicList basicLists = new BasicList();
if (this.packedWireType == WireType.None || source.WireType != WireType.String)
{
do
{
basicLists.Add(this.Tail.Read(null, source));
}while (source.TryReadFieldHeader(fieldNumber));
}
else
{
SubItemToken subItemToken = ProtoReader.StartSubItem(source);
while (ProtoReader.HasSubValue(this.packedWireType, source))
{
basicLists.Add(this.Tail.Read(null, source));
}
ProtoReader.EndSubItem(subItemToken, source);
}
if (this.AppendToCollection)
{
num = (value == null ? 0 : ((Array)value).Length);
}
else
{
num = 0;
}
int num1 = num;
Array arrays = Array.CreateInstance(this.itemType, num1 + basicLists.Count);
if (num1 != 0)
{
((Array)value).CopyTo(arrays, 0);
}
basicLists.CopyTo(arrays, num1);
return(arrays);
}
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;
bool throwNullReference = !DontThrowNullReference;
for (int i = 0; i < len; i++)
{
object obj = arr[i];
if (checkForNull && obj == null)
{
if (throwNullReference)
{
throw new NullReferenceException();
}
}
else
{
Tail.Write(obj, dest);
}
}
if (writePacked)
{
ProtoWriter.EndSubItem(token, dest);
}
}
public object Read(object value, ProtoReader source)
{
UnityEngine.Vector4 data = (UnityEngine.Vector4)value;
int fieldNumber = 0;
SubItemToken token = ProtoReader.StartSubItem(source);
while ((fieldNumber = source.ReadFieldHeader()) != 0)
{
switch (fieldNumber)
{
case 1:
data.x = source.ReadSingle();
break;
case 2:
data.y = source.ReadSingle();
break;
case 3:
data.z = source.ReadSingle();
break;
case 4:
data.w = source.ReadSingle();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
return(data);
}
public object Read(object value, ProtoReader source)
{
UnityEngine.Color32 data = (UnityEngine.Color32)value;
int fieldNumber = 0;
SubItemToken token = ProtoReader.StartSubItem(source);
while ((fieldNumber = source.ReadFieldHeader()) != 0)
{
switch (fieldNumber)
{
case 1:
data.r = source.ReadByte();
break;
case 2:
data.g = source.ReadByte();
break;
case 3:
data.b = source.ReadByte();
break;
case 4:
data.a = source.ReadByte();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
return(data);
}
private void ReadNextTableHeader()
{
ResetSchemaTable();
currentRow = null;
currentTableToken = ProtoReader.StartSubItem(reader);
AdvanceToNextField();
if (currentField == 0)
{
reachedEndOfCurrentTable = true;
ProtoReader.EndSubItem(currentTableToken, reader);
return;
}
if (currentField != 2)
{
throw new InvalidOperationException("No header found! Invalid/corrupt stream.");
}
ReadHeader();
}
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);
}
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);
}
}
}
public override object Read(object value, ProtoReader source)
{
SubItemToken subItemToken = ProtoReader.StartSubItem(source);
while (true)
{
int num = source.ReadFieldHeader();
int num1 = num;
if (num <= 0)
{
break;
}
if (num1 != 1)
{
source.SkipField();
}
else
{
value = this.Tail.Read(value, source);
}
}
ProtoReader.EndSubItem(subItemToken, source);
return(value);
}
public override void Write(object value, ProtoWriter dest)
{
IList arr = (IList)value;
int len = arr.Count;
SubItemToken token;
bool writePacked = (options & OPTIONS_WritePacked) != 0;
bool writeObject = true;
bool checkForNull = !SupportNull;
if (writePacked)
{
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, dest);
token = ProtoWriter.StartSubItem(value, dest);
ProtoWriter.SetPackedField(fieldNumber, dest);
}
else
{
token = new SubItemToken(); // default
//WireType previousWireType = dest.WireType;
ProtoWriter.WriteFieldHeader(fieldNumber, WireType.Variant, dest);
if (AsReference)
{
bool existing;
int objectKey = dest.NetCache.AddObjectKey(value, out existing);
writeObject = !existing;
ProtoWriter.WriteUInt32(existing ? (uint)objectKey : 0, dest);
}
else
{
bool isEmpty = len == 0;
ProtoWriter.WriteBoolean(isEmpty, dest);
}
//dest.WireType = previousWireType;
}
if (writeObject)
{
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 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 object Read(object value, ProtoReader source)
{
try
{
int field = source.FieldNumber;
object origValue = value;
if (value == null)
{
value = Activator.CreateInstance(concreteType);
}
bool isList = IsList && !SuppressIList;
if (packedWireType != WireType.None && source.WireType == WireType.String)
{
SubItemToken token = ProtoReader.StartSubItem(source);
if (isList)
{
IList list = (IList)value;
while (ProtoReader.HasSubValue(packedWireType, source))
{
list.Add(Tail.Read(null, source));
}
}
else
{
object[] args = new object[1];
while (ProtoReader.HasSubValue(packedWireType, source))
{
args[0] = Tail.Read(null, source);
add.Invoke(value, args);
}
}
ProtoReader.EndSubItem(token, source);
}
else
{
if (isList)
{
IList list = (IList)value;
do
{
list.Add(Tail.Read(null, source));
} while (source.TryReadFieldHeader(field));
}
else
{
object[] args = new object[1];
do
{
args[0] = Tail.Read(null, source);
add.Invoke(value, args);
} while (source.TryReadFieldHeader(field));
}
}
return(origValue == value ? null : value);
} catch (TargetInvocationException tie)
{
if (tie.InnerException != null)
{
throw tie.InnerException;
}
throw;
}
}
private void ReadNextTableHeader()
{
ResetSchemaTable();
currentRow = null;
currentTableToken = ProtoReader.StartSubItem(reader);
AdvanceToNextField();
if (currentField == 0)
{
reachedEndOfCurrentTable = true;
ProtoReader.EndSubItem(currentTableToken, reader);
return;
}
if (currentField != 2)
{
throw new InvalidOperationException("No header found! Invalid/corrupt stream.");
}
ReadHeader();
}
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
}
foreach (object subItem in (IEnumerable)value)
{
if (subItem == null) { throw new NullReferenceException(); }
Tail.Write(subItem, dest);
}
if (writePacked)
{
ProtoWriter.EndSubItem(token, dest);
}
}
private static void EndSubItem(SubItemToken token, ProtoWriter writer, PrefixStyle style)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.wireType != WireType.None)
{
throw ProtoWriter.CreateException(writer);
}
int value = token.value;
if (writer.depth <= 0)
{
throw ProtoWriter.CreateException(writer);
}
if (writer.depth-- > 25)
{
writer.PopRecursionStack();
}
writer.packedFieldNumber = 0;
if (value < 0)
{
ProtoWriter.WriteHeaderCore(-value, WireType.EndGroup, writer);
writer.wireType = WireType.None;
return;
}
switch (style)
{
case PrefixStyle.Base128:
{
int len = writer.ioIndex - value - 1;
int offset = 0;
uint tmp = (uint)len;
while ((tmp >>= 7) != 0u)
{
offset++;
}
if (offset == 0)
{
writer.ioBuffer[value] = (byte)(len & 127);
}
else
{
ProtoWriter.DemandSpace(offset, writer);
byte[] blob = writer.ioBuffer;
Helpers.BlockCopy(blob, value + 1, blob, value + 1 + offset, len);
tmp = (uint)len;
do
{
blob[value++] = (byte)((tmp & 127u) | 128u);
}while ((tmp >>= 7) != 0u);
blob[value - 1] = (byte)((int)blob[value - 1] & -129);
writer.position += offset;
writer.ioIndex += offset;
}
break;
}
case PrefixStyle.Fixed32:
{
int len = writer.ioIndex - value - 4;
ProtoWriter.WriteInt32ToBuffer(len, writer.ioBuffer, value);
break;
}
case PrefixStyle.Fixed32BigEndian:
{
int len = writer.ioIndex - value - 4;
byte[] buffer = writer.ioBuffer;
ProtoWriter.WriteInt32ToBuffer(len, buffer, value);
byte b = buffer[value];
buffer[value] = buffer[value + 3];
buffer[value + 3] = b;
b = buffer[value + 1];
buffer[value + 1] = buffer[value + 2];
buffer[value + 2] = b;
break;
}
default:
throw new ArgumentOutOfRangeException("style");
}
if (--writer.flushLock == 0 && writer.ioIndex >= 1024)
{
ProtoWriter.Flush(writer);
}
}
public static void EndSubItem(SubItemToken token, ProtoWriter writer)
{
ProtoWriter.EndSubItem(token, writer, PrefixStyle.Base128);
}
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);
}
}
}
private void WriteHeaderIfRequired()
{
if (isHeaderWritten)
return;
ProtoWriter.WriteFieldHeader(1, WireType.StartGroup, writer);
currentResultToken = ProtoWriter.StartSubItem(resultIndex, writer);
var columns = columnFactory.GetColumns(reader, options);
new HeaderWriter(writer).WriteHeader(columns);
rowWriter = new RowWriter(writer, columns, options);
isHeaderWritten = true;
}
/// <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());
}
}
