public void GotIt(Type gotType, ProtoContractAttribute gotAttr)
{
if (gotType.IsEnum)
{
using (var converter = new ProtoEnumToLuaEnumConverter(gotType, LUADir))
{
converter.Convert();
}
}
else
{
using (var converter = new ProtoClassToLuaTableConverter2(gotType, CSDir))
{
converter.Convert();
}
}
}
public void FillFromAttr(Model model, Describer describer, ProtoContractAttribute attr)
{
Name = attr.Name;
ImplicitFirstTag = attr.ImplicitFirstTag;
UseProtoMembersOnly = attr.UseProtoMembersOnly;
IgnoreListHandling = attr.IgnoreListHandling;
ImplicitFields = attr.ImplicitFields;
InferTagFromName = attr.InferTagFromName;
DataMemberOffset = attr.DataMemberOffset;
SkipConstructor = attr.SkipConstructor;
AsReferenceDefault = attr.AsReferenceDefault;
IsGroup = attr.IsGroup;
//EnumPassthru = attr.EnumPassthru;
if (attr.Surrogate != null)
{
Surrogate = describer.GetNameAddWithReferencesToModel(model, attr.Surrogate);
}
}
//获取所有设置了ProtoContractAttribute标签属性的类(PB类型)
void listPBTypes()
{
Assembly[] abs = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly ab in abs) //遍历程序集
{
foreach (Type t in ab.GetExportedTypes()) //遍历类型
{
ProtoContractAttribute attr = Attribute.GetCustomAttribute(t, typeof(ProtoContractAttribute)) as ProtoContractAttribute;
if (attr == null)
{
continue;
}
ableGen.Add(t);
if (genFilter.Count > 0 && !genFilter.Contains(t))
{
continue;
}
genList.Add(t);
}
}
}
public ProtoContractDetails(Model model, Describer describer, ProtoContractAttribute attr)
{
FillFromAttr(model, describer, attr);
}
internal void ApplyDefaultBehaviour()
{
if (type.BaseType != null && model.FindWithoutAdd(type.BaseType) == null &&
GetContractFamily(type.BaseType, null) != MetaType.AttributeFamily.None)
{
model.FindOrAddAuto(type.BaseType, true, false, false);
}
object[] typeAttribs = type.GetCustomAttributes(true);
AttributeFamily family = GetContractFamily(type, typeAttribs);
bool isEnum = type.IsEnum;
if (family == AttributeFamily.None && !isEnum)
{
return; // and you'd like me to do what, exactly?
}
BasicList partialIgnores = null, partialMembers = null;
int dataMemberOffset = 0, implicitFirstTag = 1;
bool inferTagByName = model.InferTagFromNameDefault;
ImplicitFields implicitMode = ImplicitFields.None;
for (int i = 0; i < typeAttribs.Length; i++)
{
Attribute item = (Attribute)typeAttribs[i];
if (!isEnum && item is ProtoIncludeAttribute)
{
ProtoIncludeAttribute pia = (ProtoIncludeAttribute)item;
AddSubType(pia.Tag, pia.KnownType);
}
if (item is ProtoPartialIgnoreAttribute)
{
if (partialIgnores == null)
{
partialIgnores = new BasicList();
}
partialIgnores.Add(((ProtoPartialIgnoreAttribute)item).MemberName);
}
if (!isEnum && item is ProtoPartialMemberAttribute)
{
if (partialMembers == null)
{
partialMembers = new BasicList();
}
partialMembers.Add(item);
}
if (!isEnum && item is ProtoContractAttribute)
{
ProtoContractAttribute pca = (ProtoContractAttribute)item;
dataMemberOffset = pca.DataMemberOffset;
if (pca.InferTagFromNameHasValue)
{
inferTagByName = pca.InferTagFromName;
}
implicitMode = pca.ImplicitFields;
UseConstructor = !pca.SkipConstructor;
if (pca.ImplicitFirstTag > 0)
{
implicitFirstTag = pca.ImplicitFirstTag;
}
}
}
if (implicitMode != ImplicitFields.None)
{
family &= AttributeFamily.ProtoBuf; // with implicit fields, **only** proto attributes are important
}
MethodInfo[] callbacks = null;
BasicList members = new BasicList();
foreach (MemberInfo member in type.GetMembers(isEnum ? BindingFlags.Public | BindingFlags.Static
: BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (member.DeclaringType != type)
{
continue;
}
if (member.IsDefined(typeof(ProtoIgnoreAttribute), true))
{
continue;
}
if (partialIgnores != null && partialIgnores.Contains(member.Name))
{
continue;
}
bool forced = false, isPublic, isField;
Type effectiveType;
switch (member.MemberType)
{
case MemberTypes.Property:
PropertyInfo property = (PropertyInfo)member;
effectiveType = property.PropertyType;
isPublic = property.GetGetMethod(false) != null;
isField = false;
goto ProcessMember;
case MemberTypes.Field:
FieldInfo field = (FieldInfo)member;
effectiveType = field.FieldType;
isPublic = field.IsPublic;
isField = true;
ProcessMember:
switch (implicitMode)
{
case ImplicitFields.AllFields:
if (isField)
{
forced = true;
}
break;
case ImplicitFields.AllPublic:
if (isPublic)
{
forced = true;
}
break;
}
if (effectiveType.IsSubclassOf(typeof(Delegate)))
{
continue; // we just don't like delegate types ;p
}
ProtoMemberAttribute normalizedAttribute = NormalizeProtoMember(member, family, forced, isEnum, partialMembers, dataMemberOffset, inferTagByName);
if (normalizedAttribute != null)
{
members.Add(normalizedAttribute);
}
break;
case MemberTypes.Method:
if (isEnum)
{
continue;
}
MethodInfo method = (MethodInfo)member;
object[] memberAttribs = Attribute.GetCustomAttributes(method);
if (memberAttribs != null && memberAttribs.Length > 0)
{
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoBeforeSerializationAttribute", ref callbacks, 0);
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoAfterSerializationAttribute", ref callbacks, 1);
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoBeforeDeserializationAttribute", ref callbacks, 2);
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoAfterDeserializationAttribute", ref callbacks, 3);
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnSerializingAttribute", ref callbacks, 4);
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnSerializedAttribute", ref callbacks, 5);
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnDeserializingAttribute", ref callbacks, 6);
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnDeserializedAttribute", ref callbacks, 7);
}
break;
}
}
ProtoMemberAttribute[] arr = new ProtoMemberAttribute[members.Count];
members.CopyTo(arr, 0);
if (inferTagByName || implicitMode != ImplicitFields.None)
{
Array.Sort(arr);
int nextTag = implicitFirstTag;
foreach (ProtoMemberAttribute normalizedAttribute in arr)
{
if (!normalizedAttribute.TagIsPinned) // if ProtoMember etc sets a tag, we'll trust it
{
normalizedAttribute.Rebase(nextTag++);
}
}
}
foreach (ProtoMemberAttribute normalizedAttribute in arr)
{
ValueMember vm = ApplyDefaultBehaviour(isEnum, normalizedAttribute);
if (vm != null)
{
Add(vm);
}
}
if (callbacks != null)
{
SetCallbacks(Coalesce(callbacks, 0, 4), Coalesce(callbacks, 1, 5),
Coalesce(callbacks, 2, 6), Coalesce(callbacks, 3, 7));
}
}
