public override object Read(object value, ProtoReader source)
{
int fieldNumber = source.FieldNumber;
BasicList list = new BasicList();
if ((this.packedWireType != WireType.None) && (source.WireType == WireType.String))
{
SubItemToken token = ProtoReader.StartSubItem(source);
while (ProtoReader.HasSubValue(this.packedWireType, source))
{
list.Add(base.Tail.Read(null, source));
}
ProtoReader.EndSubItem(token, source);
}
else
{
do
{
list.Add(base.Tail.Read(null, source));
}while (source.TryReadFieldHeader(fieldNumber));
}
int offset = this.AppendToCollection ? ((value == null) ? 0 : ((Array)value).Length) : 0;
Array array = Array.CreateInstance(this.itemType, (int)(offset + list.Count));
if (offset != 0)
{
((Array)value).CopyTo(array, 0);
}
list.CopyTo(array, offset);
return(array);
}
public override object Read(object value, ProtoReader source)
{
int field = source.FieldNumber;
BasicList list = new BasicList();
if (packedWireType != WireType.None && source.WireType == WireType.String)
{
SubItemToken token = ProtoReader.StartSubItem(source);
while (ProtoReader.HasSubValue(packedWireType, source))
{
list.Add(Tail.Read(null, source));
}
ProtoReader.EndSubItem(token, source);
}
else
{
do
{
list.Add(Tail.Read(null, source));
} while (source.TryReadFieldHeader(field));
}
int oldLen = AppendToCollection ? ((value == null ? 0 : ((Array)value).Length)) : 0;
Array result = Array.CreateInstance(itemType, oldLen + list.Count);
if (oldLen != 0)
{
((Array)value).CopyTo(result, 0);
}
list.CopyTo(result, oldLen);
return(result);
}
public override object Read(object value, ProtoReader source)
{
int field = source.FieldNumber;
BasicList basicList = new BasicList();
if (packedWireType != WireType.None && source.WireType == WireType.String)
{
SubItemToken token = ProtoReader.StartSubItem(source);
while (ProtoReader.HasSubValue(packedWireType, source))
{
basicList.Add(base.Tail.Read(null, source));
}
ProtoReader.EndSubItem(token, source);
}
else
{
do
{
basicList.Add(base.Tail.Read(null, source));
}while (source.TryReadFieldHeader(field));
}
int num = AppendToCollection ? ((value != null) ? ((Array)value).Length : 0) : 0;
Array array = Array.CreateInstance(itemType, num + basicList.Count);
if (num != 0)
{
((Array)value).CopyTo(array, 0);
}
basicList.CopyTo(array, num);
return(array);
}
void ReadSInstance(ProtoReader reader, SInstance sInstance, CLS_Environment environment)
{
List <CLS_Content.Value> values;
List <string> keywords;
GetSortMembers(sInstance, out values, out keywords);
int fieldNumber = 0;
while ((fieldNumber = reader.ReadFieldHeader()) > 0)
{
Type memberT = values[fieldNumber - 1].type;
CLS_Content.Value memberV = values[fieldNumber - 1];
string sClassName = keywords[fieldNumber - 1];
if (memberT == null)
{
memberT = typeof(SInstance);
sClassName = ((SType)memberV.type).Name;
}
Type itemType = GetItemType(memberT);
if (itemType != null)
{
sClassName = sInstance.type.members[sClassName].type.keyword;
// 数组判断
if (memberT.IsArray)
{
string itemClass = sClassName.Substring(0, sClassName.Length - 2); // 从 xxx[] 中提取xxx
BasicList list = new BasicList();
do
{
list.Add(ReadField(reader, itemType, itemClass, environment));
} while (reader.TryReadFieldHeader(fieldNumber));
Array result = Array.CreateInstance(itemType, list.Count);
list.CopyTo(result, 0);
memberV.value = result;
}
// 列表判断
else
{
string itemClass = sClassName.Substring(5, sClassName.Length - 6); // 从 List<xxx> 中提取xxx
ICLS_Type iType = environment.GetTypeByKeywordQuiet(sClassName);
CLS_Content content = CLS_Content.NewContent(environment);
memberV.value = iType.function.New(content, m_emptyParams).value;
CLS_Content.PoolContent(content);
IList list = (IList)memberV.value;
do
{
list.Add(ReadField(reader, itemType, itemClass, environment));
} while (reader.TryReadFieldHeader(fieldNumber));
}
}
else
{
memberV.value = ReadField(reader, memberT, sClassName, environment);
}
}
}
static string GetSchema(RuntimeTypeModel runtimeTypeModel, CliArgs args)
{
BasicList requiredTypes = new BasicList();
foreach (MetaType meta in runtimeTypeModel.GetTypes())
{
MetaType tmp = meta.GetSurrogateOrBaseOrSelf(false);
if (!requiredTypes.Contains(tmp))
{
requiredTypes.Add(tmp);
}
}
StringBuilder headerBuilder = new StringBuilder();
headerBuilder.Append("syntax = \"proto2\";").AppendLine();
headerBuilder.AppendLine();
headerBuilder.Append("option java_package = \"").Append(args.JavaPackage).Append("\";").AppendLine();
headerBuilder.Append("option java_multiple_files = true;").AppendLine();
bool requiresBclImport = false;
StringBuilder bodyBuilder = new StringBuilder();
// sort them by schema-name
MetaType[] metaTypesArr = new MetaType[requiredTypes.Count];
requiredTypes.CopyTo(metaTypesArr, 0);
Array.Sort(metaTypesArr, MetaType.Comparer.Default);
// write the messages
for (int i = 0; i < metaTypesArr.Length; i++)
{
MetaType tmp = metaTypesArr[i];
if (tmp.IsList)
{
continue;
}
tmp.WriteSchema(bodyBuilder, 0, ref requiresBclImport);
bodyBuilder.AppendLine();
}
if (requiresBclImport)
{
headerBuilder.AppendLine();
headerBuilder.Append("import \"dotnettype.proto\";").AppendLine();
}
return(headerBuilder.Append(bodyBuilder).ToString());
}
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);
}
/// <summary>
/// All this does is call GetExtendedValuesTyped with the correct type for "instance";
/// this ensures that we don't get issues with subclasses declaring conflicting types -
/// the caller must respect the fields defined for the type they pass in.
/// </summary>
internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag)
{
#if FEAT_IKVM
throw new NotSupportedException();
#else
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (tag <= 0)
{
throw new ArgumentOutOfRangeException("tag");
}
IExtension extn = instance.GetExtensionObject(false);
if (extn == null)
{
#if FX11
return(new object[0]);
#else
yield break;
#endif
}
#if FX11
BasicList result = new BasicList();
#endif
Stream stream = extn.BeginQuery();
object value = null;
ProtoReader reader = null;
try {
SerializationContext ctx = new SerializationContext();
reader = ProtoReader.Create(stream, model, ctx, ProtoReader.TO_EOF);
while (model.TryDeserializeAuxiliaryType(reader, format, tag, type, ref value, true, false, false, false) && value != null)
{
if (!singleton)
{
#if FX11
result.Add(value);
#else
yield return(value);
#endif
value = null; // fresh item each time
}
}
if (singleton && value != null)
{
#if FX11
result.Add(value);
#else
yield return(value);
#endif
}
#if FX11
object[] resultArr = new object[result.Count];
result.CopyTo(resultArr, 0);
return(resultArr);
#endif
} finally {
ProtoReader.Recycle(reader);
extn.EndQuery(stream);
}
#endif
}
private bool TryDeserializeList(TypeModel model, ProtoReader reader, DataFormat format, int tag, Type listType, Type itemType, ref object value)
{
bool isList;
MethodInfo addMethod = TypeModel.ResolveListAdd(model, listType, itemType, out isList);
if (addMethod == null)
{
throw new NotSupportedException("Unknown list variant: " + listType.FullName);
}
bool found = false;
object nextItem = null;
IList list = value as IList;
object[] args = isList ? null : new object[1];
BasicList arraySurrogate = listType.IsArray ? new BasicList() : null;
while (this.TryDeserializeAuxiliaryType(reader, format, tag, itemType, ref nextItem, true, true, true, true))
{
found = true;
if (value == null && arraySurrogate == null)
{
value = TypeModel.CreateListInstance(listType, itemType);
list = (value as IList);
}
if (list != null)
{
list.Add(nextItem);
}
else
{
if (arraySurrogate != null)
{
arraySurrogate.Add(nextItem);
}
else
{
args[0] = nextItem;
addMethod.Invoke(value, args);
}
}
nextItem = null;
}
if (arraySurrogate != null)
{
if (value != null)
{
if (arraySurrogate.Count != 0)
{
Array existing = (Array)value;
Array newArray = Array.CreateInstance(itemType, existing.Length + arraySurrogate.Count);
Array.Copy(existing, newArray, existing.Length);
arraySurrogate.CopyTo(newArray, existing.Length);
value = newArray;
}
}
else
{
Array newArray = Array.CreateInstance(itemType, arraySurrogate.Count);
arraySurrogate.CopyTo(newArray, 0);
value = newArray;
}
}
return(found);
}
public override string GetSchema(Type type)
{
BasicList requiredTypes = new BasicList();
MetaType primaryType = null;
bool isInbuiltType = false;
if (type == null)
{
BasicList.NodeEnumerator enumerator = this.types.GetEnumerator();
while (enumerator.MoveNext())
{
MetaType meta = (MetaType)enumerator.Current;
MetaType tmp = meta.GetSurrogateOrBaseOrSelf(false);
if (!requiredTypes.Contains(tmp))
{
requiredTypes.Add(tmp);
this.CascadeDependents(requiredTypes, tmp);
}
}
}
else
{
Type tmp2 = Helpers.GetUnderlyingType(type);
if (tmp2 != null)
{
type = tmp2;
}
WireType defaultWireType;
isInbuiltType = (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out defaultWireType, false, false, false, false) != null);
if (!isInbuiltType)
{
int index = this.FindOrAddAuto(type, false, false, false);
if (index < 0)
{
throw new ArgumentException("The type specified is not a contract-type", "type");
}
primaryType = ((MetaType)this.types[index]).GetSurrogateOrBaseOrSelf(false);
requiredTypes.Add(primaryType);
this.CascadeDependents(requiredTypes, primaryType);
}
}
StringBuilder headerBuilder = new StringBuilder();
string package = null;
if (!isInbuiltType)
{
IEnumerable typesForNamespace = (primaryType == null) ? this.types : requiredTypes;
foreach (MetaType meta2 in typesForNamespace)
{
if (!meta2.IsList)
{
string tmp3 = meta2.Type.Namespace;
if (!Helpers.IsNullOrEmpty(tmp3) && !tmp3.StartsWith("System."))
{
if (package == null)
{
package = tmp3;
}
else
{
if (!(package == tmp3))
{
package = null;
break;
}
}
}
}
}
}
if (!Helpers.IsNullOrEmpty(package))
{
headerBuilder.Append("package ").Append(package).Append(';');
Helpers.AppendLine(headerBuilder);
}
bool requiresBclImport = false;
StringBuilder bodyBuilder = new StringBuilder();
MetaType[] metaTypesArr = new MetaType[requiredTypes.Count];
requiredTypes.CopyTo(metaTypesArr, 0);
Array.Sort <MetaType>(metaTypesArr, MetaType.Comparer.Default);
if (isInbuiltType)
{
Helpers.AppendLine(bodyBuilder).Append("message ").Append(type.Name).Append(" {");
MetaType.NewLine(bodyBuilder, 1).Append("optional ").Append(this.GetSchemaTypeName(type, DataFormat.Default, false, false, ref requiresBclImport)).Append(" value = 1;");
Helpers.AppendLine(bodyBuilder).Append('}');
}
else
{
for (int i = 0; i < metaTypesArr.Length; i++)
{
MetaType tmp4 = metaTypesArr[i];
if (!tmp4.IsList || tmp4 == primaryType)
{
tmp4.WriteSchema(bodyBuilder, 0, ref requiresBclImport);
}
}
}
if (requiresBclImport)
{
headerBuilder.Append("import \"bcl.proto\"; // schema for protobuf-net's handling of core .NET types");
Helpers.AppendLine(headerBuilder);
}
return(Helpers.AppendLine(headerBuilder.Append(bodyBuilder)).ToString());
}
