private void CascadeDependents(BasicList list, MetaType metaType)
{
MetaType surrogateOrBaseOrSelf;
if (metaType.IsList)
{
Type listItemType = TypeModel.GetListItemType(this, metaType.Type);
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, listItemType, out WireType _, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false) != null)
{
return;
}
int num = FindOrAddAuto(listItemType, demand: false, addWithContractOnly: false, addEvenIfAutoDisabled: false);
if (num >= 0)
{
surrogateOrBaseOrSelf = ((MetaType)types[num]).GetSurrogateOrBaseOrSelf(deep: false);
if (!list.Contains(surrogateOrBaseOrSelf))
{
list.Add(surrogateOrBaseOrSelf);
CascadeDependents(list, surrogateOrBaseOrSelf);
}
}
return;
}
if (metaType.IsAutoTuple)
{
if (MetaType.ResolveTupleConstructor(metaType.Type, out MemberInfo[] mappedMembers) != null)
private void CascadeDependents(BasicList list, MetaType metaType)
{
if (metaType.IsList)
{
Type listItemType = TypeModel.GetListItemType(this, metaType.Type);
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, listItemType, out WireType _, false, false, false, false) == null)
{
int num = FindOrAddAuto(listItemType, false, false, false);
if (num >= 0)
{
MetaType surrogateOrBaseOrSelf = ((MetaType)types[num]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(surrogateOrBaseOrSelf))
{
list.Add(surrogateOrBaseOrSelf);
CascadeDependents(list, surrogateOrBaseOrSelf);
}
}
}
}
else
{
MetaType surrogateOrBaseOrSelf;
if (metaType.IsAutoTuple)
{
if (MetaType.ResolveTupleConstructor(metaType.Type, out MemberInfo[] array) != (ConstructorInfo)null)
private static void TestEnumerableListPatterns(TypeModel model, BasicList candidates, Type iType)
{
if (iType.IsGenericType)
{
Type genericTypeDefinition = iType.GetGenericTypeDefinition();
if (!(genericTypeDefinition == model.MapType(typeof(IEnumerable <>))) && !(genericTypeDefinition == model.MapType(typeof(ICollection <>))) && !(genericTypeDefinition.FullName == "System.Collections.Concurrent.IProducerConsumerCollection`1"))
{
return;
}
Type[] genericArguments = iType.GetGenericArguments();
if (!candidates.Contains(genericArguments[0]))
{
candidates.Add(genericArguments[0]);
}
}
}
private void CascadeDependents(BasicList list, MetaType metaType)
{
MetaType tmp;
if (metaType.IsList)
{
Type itemType = TypeModel.GetListItemType(this, metaType.Type);
WireType defaultWireType;
IProtoSerializer coreSerializer = ValueMember.TryGetCoreSerializer(this, DataFormat.Default, itemType, out defaultWireType, false, false, false, false);
if (coreSerializer == null)
{
int index = FindOrAddAuto(itemType, false, false, false);
if (index >= 0)
{
tmp = ((MetaType)types[index]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(tmp))
{ // could perhaps also implement as a queue, but this should work OK for sane models
list.Add(tmp);
CascadeDependents(list, tmp);
}
}
}
}
else
{
if (metaType.IsAutoTuple)
{
MemberInfo[] mapping;
if(MetaType.ResolveTupleConstructor(metaType.Type, out mapping) != null)
{
for (int i = 0; i < mapping.Length; i++)
{
Type type = null;
if (mapping[i] is PropertyInfo) type = ((PropertyInfo)mapping[i]).PropertyType;
else if (mapping[i] is FieldInfo) type = ((FieldInfo)mapping[i]).FieldType;
WireType defaultWireType;
IProtoSerializer coreSerializer = ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out defaultWireType, false, false, false, false);
if (coreSerializer == null)
{
int index = FindOrAddAuto(type, false, false, false);
if (index >= 0)
{
tmp = ((MetaType)types[index]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(tmp))
{ // could perhaps also implement as a queue, but this should work OK for sane models
list.Add(tmp);
CascadeDependents(list, tmp);
}
}
}
}
}
}
else
{
foreach (ValueMember member in metaType.Fields)
{
Type type = member.ItemType;
if (type == null) type = member.MemberType;
WireType defaultWireType;
IProtoSerializer coreSerializer = ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out defaultWireType, false, false, false, false);
if (coreSerializer == null)
{
// is an interesting type
int index = FindOrAddAuto(type, false, false, false);
if (index >= 0)
{
tmp = ((MetaType)types[index]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(tmp))
{ // could perhaps also implement as a queue, but this should work OK for sane models
list.Add(tmp);
CascadeDependents(list, tmp);
}
}
}
}
}
if (metaType.HasSubtypes)
{
foreach (SubType subType in metaType.GetSubtypes())
{
tmp = subType.DerivedType.GetSurrogateOrSelf(); // note: exclude base-types!
if (!list.Contains(tmp))
{
list.Add(tmp);
CascadeDependents(list, tmp);
}
}
}
tmp = metaType.BaseType;
if (tmp != null) tmp = tmp.GetSurrogateOrSelf(); // note: already walking base-types; exclude base
if (tmp != null && !list.Contains(tmp))
{
list.Add(tmp);
CascadeDependents(list, tmp);
}
}
}
/// <summary>
/// Suggest a .proto definition for the given type
/// </summary>
/// <param name="type">The type to generate a .proto definition for, or <c>null</c> to generate a .proto that represents the entire model</param>
/// <returns>The .proto definition as a string</returns>
public override string GetSchema(Type type)
{
BasicList requiredTypes = new BasicList();
MetaType primaryType = null;
bool isInbuiltType = false;
if (type == null)
{ // generate for the entire model
foreach(MetaType meta in types)
{
MetaType tmp = meta.GetSurrogateOrBaseOrSelf(false);
if (!requiredTypes.Contains(tmp))
{ // ^^^ note that the type might have been added as a descendent
requiredTypes.Add(tmp);
CascadeDependents(requiredTypes, tmp);
}
}
}
else
{
Type tmp = Helpers.GetUnderlyingType(type);
if (tmp != null) type = tmp;
WireType defaultWireType;
isInbuiltType = (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out defaultWireType, false, false, false, false) != null);
if (!isInbuiltType)
{
//Agenerate just relative to the supplied type
int index = FindOrAddAuto(type, false, false, false);
if (index < 0) throw new ArgumentException("The type specified is not a contract-type", "type");
// get the required types
primaryType = ((MetaType)types[index]).GetSurrogateOrBaseOrSelf(false);
requiredTypes.Add(primaryType);
CascadeDependents(requiredTypes, primaryType);
}
}
// use the provided type's namespace for the "package"
StringBuilder headerBuilder = new StringBuilder();
string package = null;
if (!isInbuiltType)
{
IEnumerable typesForNamespace = primaryType == null ? types : requiredTypes;
foreach (MetaType meta in typesForNamespace)
{
if (meta.IsList) continue;
string tmp = meta.Type.Namespace;
if (!Helpers.IsNullOrEmpty(tmp))
{
if (tmp.StartsWith("System.")) continue;
if (package == null)
{ // haven't seen any suggestions yet
package = tmp;
}
else if (package == tmp)
{ // that's fine; a repeat of the one we already saw
}
else
{ // something else; have confliucting suggestions; abort
package = null;
break;
}
}
}
}
if (!Helpers.IsNullOrEmpty(package))
{
headerBuilder.Append("package ").Append(package).Append(';');
Helpers.AppendLine(headerBuilder);
}
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
if (isInbuiltType)
{
Helpers.AppendLine(bodyBuilder).Append("message ").Append(type.Name).Append(" {");
MetaType.NewLine(bodyBuilder, 1).Append("optional ").Append(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 tmp = metaTypesArr[i];
if (tmp.IsList && tmp != primaryType) continue;
tmp.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();
}
// Token: 0x0600036A RID: 874 RVA: 0x00012A1C File Offset: 0x00010C1C
private void CascadeDependents(BasicList list, MetaType metaType)
{
if (metaType.IsList)
{
Type listItemType = TypeModel.GetListItemType(this, metaType.Type);
WireType wireType;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, listItemType, out wireType, false, false, false, false) == null)
{
int num = this.FindOrAddAuto(listItemType, false, false, false);
if (num >= 0)
{
MetaType metaType2 = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
return;
}
}
}
}
else
{
MetaType metaType2;
if (metaType.IsAutoTuple)
{
MemberInfo[] array;
if (MetaType.ResolveTupleConstructor(metaType.Type, out array) != null)
{
for (int i = 0; i < array.Length; i++)
{
Type type = null;
if (array[i] is PropertyInfo)
{
type = ((PropertyInfo)array[i]).PropertyType;
}
else if (array[i] is FieldInfo)
{
type = ((FieldInfo)array[i]).FieldType;
}
WireType wireType2;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType2, false, false, false, false) == null)
{
int num2 = this.FindOrAddAuto(type, false, false, false);
if (num2 >= 0)
{
metaType2 = ((MetaType)this.types[num2]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
}
}
else
{
foreach (object obj in metaType.Fields)
{
ValueMember valueMember = (ValueMember)obj;
Type type2 = valueMember.ItemType;
if (type2 == null)
{
type2 = valueMember.MemberType;
}
WireType wireType3;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type2, out wireType3, false, false, false, false) == null)
{
int num3 = this.FindOrAddAuto(type2, false, false, false);
if (num3 >= 0)
{
metaType2 = ((MetaType)this.types[num3]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
}
if (metaType.HasSubtypes)
{
SubType[] subtypes = metaType.GetSubtypes();
for (int j = 0; j < subtypes.Length; j++)
{
metaType2 = subtypes[j].DerivedType.GetSurrogateOrSelf();
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
metaType2 = metaType.BaseType;
if (metaType2 != null)
{
metaType2 = metaType2.GetSurrogateOrSelf();
}
if (metaType2 != null && !list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
// Token: 0x06000369 RID: 873 RVA: 0x00012780 File Offset: 0x00010980
public override string GetSchema(Type type)
{
BasicList basicList = new BasicList();
MetaType metaType = null;
bool flag = false;
if (type == null)
{
foreach (object obj in this.types)
{
MetaType surrogateOrBaseOrSelf = ((MetaType)obj).GetSurrogateOrBaseOrSelf(false);
if (!basicList.Contains(surrogateOrBaseOrSelf))
{
basicList.Add(surrogateOrBaseOrSelf);
this.CascadeDependents(basicList, surrogateOrBaseOrSelf);
}
}
}
else
{
Type underlyingType = Helpers.GetUnderlyingType(type);
if (underlyingType != null)
{
type = underlyingType;
}
WireType wireType;
flag = (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType, false, false, false, false) != null);
if (!flag)
{
int num = this.FindOrAddAuto(type, false, false, false);
if (num < 0)
{
throw new ArgumentException("The type specified is not a contract-type", "type");
}
metaType = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false);
basicList.Add(metaType);
this.CascadeDependents(basicList, metaType);
}
}
StringBuilder stringBuilder = new StringBuilder();
string text = null;
if (!flag)
{
foreach (object obj2 in ((IEnumerable)((metaType == null) ? this.types : basicList)))
{
MetaType metaType2 = (MetaType)obj2;
if (!metaType2.IsList)
{
string @namespace = metaType2.Type.Namespace;
if (!Helpers.IsNullOrEmpty(@namespace) && [email protected]("System."))
{
if (text == null)
{
text = @namespace;
}
else if (!(text == @namespace))
{
text = null;
break;
}
}
}
}
}
if (!Helpers.IsNullOrEmpty(text))
{
stringBuilder.Append("package ").Append(text).Append(';');
Helpers.AppendLine(stringBuilder);
}
bool flag2 = false;
StringBuilder stringBuilder2 = new StringBuilder();
MetaType[] array = new MetaType[basicList.Count];
basicList.CopyTo(array, 0);
Array.Sort <MetaType>(array, MetaType.Comparer.Default);
if (flag)
{
Helpers.AppendLine(stringBuilder2).Append("message ").Append(type.Name).Append(" {");
MetaType.NewLine(stringBuilder2, 1).Append("optional ").Append(this.GetSchemaTypeName(type, DataFormat.Default, false, false, ref flag2)).Append(" value = 1;");
Helpers.AppendLine(stringBuilder2).Append('}');
}
else
{
foreach (MetaType metaType3 in array)
{
if (!metaType3.IsList || metaType3 == metaType)
{
metaType3.WriteSchema(stringBuilder2, 0, ref flag2);
}
}
}
if (flag2)
{
stringBuilder.Append("import \"bcl.proto\"; // schema for protobuf-net's handling of core .NET types");
Helpers.AppendLine(stringBuilder);
}
return(Helpers.AppendLine(stringBuilder.Append(stringBuilder2)).ToString());
}
private void CascadeDependents(BasicList list, MetaType metaType)
{
if (metaType.IsList)
{
Type listItemType = TypeModel.GetListItemType(this, metaType.Type);
WireType wireType;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, listItemType, out wireType, false, false, false, false) == null)
{
int num = this.FindOrAddAuto(listItemType, false, false, false);
if (num >= 0)
{
MetaType metaType2 = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
else
{
MetaType metaType2;
if (metaType.IsAutoTuple)
{
MemberInfo[] array;
if (MetaType.ResolveTupleConstructor(metaType.Type, out array) != null)
{
for (int i = 0; i < array.Length; i++)
{
Type type = null;
if (array[i] is PropertyInfo)
{
type = ((PropertyInfo)array[i]).PropertyType;
}
else if (array[i] is FieldInfo)
{
type = ((FieldInfo)array[i]).FieldType;
}
WireType wireType2;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType2, false, false, false, false) == null)
{
int num2 = this.FindOrAddAuto(type, false, false, false);
if (num2 >= 0)
{
metaType2 = ((MetaType)this.types[num2]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
}
}
else
{
foreach (ValueMember valueMember in metaType.Fields)
{
Type type2 = valueMember.ItemType;
if (type2 == null)
{
type2 = valueMember.MemberType;
}
WireType wireType3;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type2, out wireType3, false, false, false, false) == null)
{
int num3 = this.FindOrAddAuto(type2, false, false, false);
if (num3 >= 0)
{
metaType2 = ((MetaType)this.types[num3]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
}
if (metaType.HasSubtypes)
{
SubType[] subtypes = metaType.GetSubtypes();
for (int j = 0; j < subtypes.Length; j++)
{
SubType subType = subtypes[j];
metaType2 = subType.DerivedType.GetSurrogateOrSelf();
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
metaType2 = metaType.BaseType;
if (metaType2 != null)
{
metaType2 = metaType2.GetSurrogateOrSelf();
}
if (metaType2 != null && !list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
public override string GetSchema(Type type)
{
BasicList basicList = new BasicList();
MetaType metaType = null;
bool flag = false;
if (type == null)
{
BasicList.NodeEnumerator enumerator = this.types.GetEnumerator();
while (enumerator.MoveNext())
{
MetaType metaType2 = (MetaType)enumerator.Current;
MetaType surrogateOrBaseOrSelf = metaType2.GetSurrogateOrBaseOrSelf(false);
if (!basicList.Contains(surrogateOrBaseOrSelf))
{
basicList.Add(surrogateOrBaseOrSelf);
this.CascadeDependents(basicList, surrogateOrBaseOrSelf);
}
}
}
else
{
Type underlyingType = Helpers.GetUnderlyingType(type);
if (underlyingType != null)
{
type = underlyingType;
}
WireType wireType;
flag = (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType, false, false, false, false) != null);
if (!flag)
{
int num = this.FindOrAddAuto(type, false, false, false);
if (num < 0)
{
throw new ArgumentException("The type specified is not a contract-type", "type");
}
metaType = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false);
basicList.Add(metaType);
this.CascadeDependents(basicList, metaType);
}
}
StringBuilder stringBuilder = new StringBuilder();
string text = null;
if (!flag)
{
IEnumerable enumerable = (metaType != null) ? basicList : this.types;
foreach (MetaType metaType3 in enumerable)
{
if (!metaType3.IsList)
{
string @namespace = metaType3.Type.Namespace;
if (!Helpers.IsNullOrEmpty(@namespace))
{
if ([email protected]("System."))
{
if (text == null)
{
text = @namespace;
}
else if (!(text == @namespace))
{
text = null;
break;
}
}
}
}
}
}
if (!Helpers.IsNullOrEmpty(text))
{
stringBuilder.Append("package ").Append(text).Append(';');
Helpers.AppendLine(stringBuilder);
}
bool flag2 = false;
StringBuilder stringBuilder2 = new StringBuilder();
MetaType[] array = new MetaType[basicList.Count];
basicList.CopyTo(array, 0);
Array.Sort<MetaType>(array, MetaType.Comparer.Default);
if (flag)
{
Helpers.AppendLine(stringBuilder2).Append("message ").Append(type.Name).Append(" {");
MetaType.NewLine(stringBuilder2, 1).Append("optional ").Append(this.GetSchemaTypeName(type, DataFormat.Default, false, false, ref flag2)).Append(" value = 1;");
Helpers.AppendLine(stringBuilder2).Append('}');
}
else
{
for (int i = 0; i < array.Length; i++)
{
MetaType metaType4 = array[i];
if (!metaType4.IsList || metaType4 == metaType)
{
metaType4.WriteSchema(stringBuilder2, 0, ref flag2);
}
}
}
if (flag2)
{
stringBuilder.Append("import \"bcl.proto\"; // schema for protobuf-net's handling of core .NET types");
Helpers.AppendLine(stringBuilder);
}
return Helpers.AppendLine(stringBuilder.Append(stringBuilder2)).ToString();
}
internal static Type GetListItemType(Type listType)
{
Helpers.DebugAssert(listType != null);
if (listType == typeof(string) || listType.IsArray
|| !typeof(IEnumerable).IsAssignableFrom(listType)) return null;
BasicList candidates = new BasicList();
candidates.Add(typeof(object));
foreach (MethodInfo method in listType.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
if (method.Name != "Add") continue;
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length == 1 && !candidates.Contains(parameters[0].ParameterType))
{
candidates.Add(parameters[0].ParameterType);
}
}
foreach (Type iType in listType.GetInterfaces())
{
if (iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof(System.Collections.Generic.ICollection<>))
{
Type[] iTypeArgs = iType.GetGenericArguments();
if (!candidates.Contains(iTypeArgs[0]))
{
candidates.Add(iTypeArgs[0]);
}
}
}
// more convenient GetProperty overload not supported on all platforms
foreach (PropertyInfo indexer in listType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
if (indexer.Name != "Item" || candidates.Contains(indexer.PropertyType)) continue;
ParameterInfo[] args = indexer.GetIndexParameters();
if (args.Length != 1 || args[0].ParameterType != typeof(int)) continue;
candidates.Add(indexer.PropertyType);
}
switch (candidates.Count)
{
case 1:
return null;
case 2:
return (Type)candidates[1];
case 3:
if (CheckDictionaryAccessors((Type)candidates[1], (Type)candidates[2])) return (Type)candidates[1];
if (CheckDictionaryAccessors((Type)candidates[2], (Type)candidates[1])) return (Type)candidates[2];
break;
}
return null;
}
internal static Type GetListItemType(Type listType)
{
Helpers.DebugAssert(listType != null);
if (listType == typeof(string) || listType.IsArray ||
!typeof(IEnumerable).IsAssignableFrom(listType))
{
return(null);
}
BasicList candidates = new BasicList();
candidates.Add(typeof(object));
foreach (MethodInfo method in listType.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
if (method.Name != "Add")
{
continue;
}
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length == 1 && !candidates.Contains(parameters[0].ParameterType))
{
candidates.Add(parameters[0].ParameterType);
}
}
foreach (Type iType in listType.GetInterfaces())
{
if (iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof(System.Collections.Generic.ICollection <>))
{
Type[] iTypeArgs = iType.GetGenericArguments();
if (!candidates.Contains(iTypeArgs[0]))
{
candidates.Add(iTypeArgs[0]);
}
}
}
// more convenient GetProperty overload not supported on all platforms
foreach (PropertyInfo indexer in listType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
if (indexer.Name != "Item" || candidates.Contains(indexer.PropertyType))
{
continue;
}
ParameterInfo[] args = indexer.GetIndexParameters();
if (args.Length != 1 || args[0].ParameterType != typeof(int))
{
continue;
}
candidates.Add(indexer.PropertyType);
}
switch (candidates.Count)
{
case 1:
return(null);
case 2:
return((Type)candidates[1]);
case 3:
if (CheckDictionaryAccessors((Type)candidates[1], (Type)candidates[2]))
{
return((Type)candidates[1]);
}
if (CheckDictionaryAccessors((Type)candidates[2], (Type)candidates[1]))
{
return((Type)candidates[2]);
}
break;
}
return(null);
}
internal static Type GetListItemType(TypeModel model, Type listType)
{
if (listType == model.MapType(typeof(string)) || listType.IsArray || !model.MapType(typeof(IEnumerable)).IsAssignableFrom(listType))
{
return(null);
}
BasicList basicList = new BasicList();
MethodInfo[] methods = listType.GetMethods();
foreach (MethodInfo methodInfo in methods)
{
if (!methodInfo.IsStatic && !(methodInfo.Name != "Add"))
{
ParameterInfo[] parameters = methodInfo.GetParameters();
Type parameterType;
if (parameters.Length == 1 && !basicList.Contains(parameterType = parameters[0].ParameterType))
{
basicList.Add(parameterType);
}
}
}
string name = listType.Name;
if (name == null || (name.IndexOf("Queue") < 0 && name.IndexOf("Stack") < 0))
{
TestEnumerableListPatterns(model, basicList, listType);
Type[] interfaces = listType.GetInterfaces();
foreach (Type iType in interfaces)
{
TestEnumerableListPatterns(model, basicList, iType);
}
}
PropertyInfo[] properties = listType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (PropertyInfo propertyInfo in properties)
{
if (!(propertyInfo.Name != "Item") && !basicList.Contains(propertyInfo.PropertyType))
{
ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
if (indexParameters.Length == 1 && indexParameters[0].ParameterType == model.MapType(typeof(int)))
{
basicList.Add(propertyInfo.PropertyType);
}
}
}
switch (basicList.Count)
{
case 0:
return(null);
case 1:
return((Type)basicList[0]);
case 2:
if (CheckDictionaryAccessors(model, (Type)basicList[0], (Type)basicList[1]))
{
return((Type)basicList[0]);
}
if (CheckDictionaryAccessors(model, (Type)basicList[1], (Type)basicList[0]))
{
return((Type)basicList[1]);
}
break;
}
return(null);
}
private void CascadeDependents(BasicList list, MetaType metaType)
{
if (metaType.IsList)
{
Type listItemType = TypeModel.GetListItemType(this, metaType.Type);
WireType wireType;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, listItemType, out wireType, false, false, false, false) == null)
{
int num = this.FindOrAddAuto(listItemType, false, false, false);
if (num >= 0)
{
MetaType metaType2 = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
else
{
MetaType metaType2;
if (metaType.IsAutoTuple)
{
MemberInfo[] array;
if (MetaType.ResolveTupleConstructor(metaType.Type, out array) != null)
{
for (int i = 0; i < array.Length; i++)
{
Type type = null;
if (array[i] is PropertyInfo)
{
type = ((PropertyInfo)array[i]).get_PropertyType();
}
else if (array[i] is FieldInfo)
{
type = ((FieldInfo)array[i]).get_FieldType();
}
WireType wireType2;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType2, false, false, false, false) == null)
{
int num2 = this.FindOrAddAuto(type, false, false, false);
if (num2 >= 0)
{
metaType2 = ((MetaType)this.types[num2]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
}
}
else
{
IEnumerator enumerator = metaType.Fields.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
ValueMember valueMember = (ValueMember)enumerator.get_Current();
Type type2 = valueMember.ItemType;
if (type2 == null)
{
type2 = valueMember.MemberType;
}
WireType wireType3;
if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type2, out wireType3, false, false, false, false) == null)
{
int num3 = this.FindOrAddAuto(type2, false, false, false);
if (num3 >= 0)
{
metaType2 = ((MetaType)this.types[num3]).GetSurrogateOrBaseOrSelf(false);
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
if (metaType.HasSubtypes)
{
SubType[] subtypes = metaType.GetSubtypes();
for (int j = 0; j < subtypes.Length; j++)
{
SubType subType = subtypes[j];
metaType2 = subType.DerivedType.GetSurrogateOrSelf();
if (!list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
metaType2 = metaType.BaseType;
if (metaType2 != null)
{
metaType2 = metaType2.GetSurrogateOrSelf();
}
if (metaType2 != null && !list.Contains(metaType2))
{
list.Add(metaType2);
this.CascadeDependents(list, metaType2);
}
}
}
public override string GetSchema(Type type)
{
BasicList basicList = new BasicList();
MetaType metaType = null;
bool flag = false;
if (type == null)
{
BasicList.NodeEnumerator enumerator = this.types.GetEnumerator();
while (enumerator.MoveNext())
{
MetaType metaType2 = (MetaType)enumerator.Current;
MetaType surrogateOrBaseOrSelf = metaType2.GetSurrogateOrBaseOrSelf(false);
if (!basicList.Contains(surrogateOrBaseOrSelf))
{
basicList.Add(surrogateOrBaseOrSelf);
this.CascadeDependents(basicList, surrogateOrBaseOrSelf);
}
}
}
else
{
Type underlyingType = Helpers.GetUnderlyingType(type);
if (underlyingType != null)
{
type = underlyingType;
}
WireType wireType;
flag = (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out wireType, false, false, false, false) != null);
if (!flag)
{
int num = this.FindOrAddAuto(type, false, false, false);
if (num < 0)
{
throw new ArgumentException("The type specified is not a contract-type", "type");
}
metaType = ((MetaType)this.types[num]).GetSurrogateOrBaseOrSelf(false);
basicList.Add(metaType);
this.CascadeDependents(basicList, metaType);
}
}
StringBuilder stringBuilder = new StringBuilder();
string text = null;
if (!flag)
{
IEnumerable enumerable = (metaType != null) ? basicList : this.types;
IEnumerator enumerator2 = enumerable.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
MetaType metaType3 = (MetaType)enumerator2.get_Current();
if (!metaType3.IsList)
{
string @namespace = metaType3.Type.get_Namespace();
if (!Helpers.IsNullOrEmpty(@namespace))
{
if ([email protected]("System."))
{
if (text == null)
{
text = @namespace;
}
else if (!(text == @namespace))
{
text = null;
break;
}
}
}
}
}
}
finally
{
IDisposable disposable = enumerator2 as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
if (!Helpers.IsNullOrEmpty(text))
{
stringBuilder.Append("package ").Append(text).Append(';');
Helpers.AppendLine(stringBuilder);
}
bool flag2 = false;
StringBuilder stringBuilder2 = new StringBuilder();
MetaType[] array = new MetaType[basicList.Count];
basicList.CopyTo(array, 0);
Array.Sort <MetaType>(array, MetaType.Comparer.Default);
if (flag)
{
Helpers.AppendLine(stringBuilder2).Append("message ").Append(type.get_Name()).Append(" {");
MetaType.NewLine(stringBuilder2, 1).Append("optional ").Append(this.GetSchemaTypeName(type, DataFormat.Default, false, false, ref flag2)).Append(" value = 1;");
Helpers.AppendLine(stringBuilder2).Append('}');
}
else
{
for (int i = 0; i < array.Length; i++)
{
MetaType metaType4 = array[i];
if (!metaType4.IsList || metaType4 == metaType)
{
metaType4.WriteSchema(stringBuilder2, 0, ref flag2);
}
}
}
if (flag2)
{
stringBuilder.Append("import \"bcl.proto\"; // schema for protobuf-net's handling of core .NET types");
Helpers.AppendLine(stringBuilder);
}
return(Helpers.AppendLine(stringBuilder.Append(stringBuilder2)).ToString());
}
public override string GetSchema(Type type)
{
BasicList basicList = new BasicList();
MetaType metaType = null;
bool flag = false;
if (type == null)
{
BasicList.NodeEnumerator enumerator = types.GetEnumerator();
while (enumerator.MoveNext())
{
MetaType surrogateOrBaseOrSelf = ((MetaType)enumerator.Current).GetSurrogateOrBaseOrSelf(deep: false);
if (!basicList.Contains(surrogateOrBaseOrSelf))
{
basicList.Add(surrogateOrBaseOrSelf);
CascadeDependents(basicList, surrogateOrBaseOrSelf);
}
}
}
else
{
Type underlyingType = Helpers.GetUnderlyingType(type);
if (underlyingType != null)
{
type = underlyingType;
}
flag = (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, type, out WireType _, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false) != null);
if (!flag)
{
int num = FindOrAddAuto(type, demand: false, addWithContractOnly: false, addEvenIfAutoDisabled: false);
if (num < 0)
{
throw new ArgumentException("The type specified is not a contract-type", "type");
}
metaType = ((MetaType)types[num]).GetSurrogateOrBaseOrSelf(deep: false);
basicList.Add(metaType);
CascadeDependents(basicList, metaType);
}
}
StringBuilder stringBuilder = new StringBuilder();
string text = null;
if (!flag)
{
foreach (MetaType item in (IEnumerable)((metaType == null) ? types : basicList))
{
if (!item.IsList)
{
string @namespace = item.Type.Namespace;
if (!Helpers.IsNullOrEmpty(@namespace) && [email protected]("System."))
{
if (text == null)
{
text = @namespace;
}
else if (!(text == @namespace))
{
text = null;
break;
}
}
}
}
}
if (!Helpers.IsNullOrEmpty(text))
{
stringBuilder.Append("package ").Append(text).Append(';');
Helpers.AppendLine(stringBuilder);
}
bool requiresBclImport = false;
StringBuilder stringBuilder2 = new StringBuilder();
MetaType[] array = new MetaType[basicList.Count];
basicList.CopyTo(array, 0);
Array.Sort(array, MetaType.Comparer.Default);
if (flag)
{
Helpers.AppendLine(stringBuilder2).Append("message ").Append(type.Name)
.Append(" {");
MetaType.NewLine(stringBuilder2, 1).Append("optional ").Append(GetSchemaTypeName(type, DataFormat.Default, asReference: false, dynamicType: false, ref requiresBclImport))
.Append(" value = 1;");
Helpers.AppendLine(stringBuilder2).Append('}');
}
else
{
foreach (MetaType metaType3 in array)
{
if (!metaType3.IsList || metaType3 == metaType)
{
metaType3.WriteSchema(stringBuilder2, 0, ref requiresBclImport);
}
}
}
if (requiresBclImport)
{
stringBuilder.Append("import \"bcl.proto\"; // schema for protobuf-net's handling of core .NET types");
Helpers.AppendLine(stringBuilder);
}
return(Helpers.AppendLine(stringBuilder.Append(stringBuilder2)).ToString());
}
