blob: d028860b8a771d52819a71beec8f4d1cfcd04d73 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using ProtoBuf.Meta;
namespace Tango.Transport
{
public static class AutoProtobuf
{
private const BindingFlags Flags = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
private static readonly Dictionary<Type, HashSet<Type>> SubTypes = new Dictionary<Type, HashSet<Type>>();
private static readonly ConcurrentBag<Type> BuiltTypes = new ConcurrentBag<Type>();
private static readonly Type ObjectType = typeof(object);
/// <summary>
/// Build the ProtoBuf serializer from the generic <see cref="Type">type</see>.
/// </summary>
/// <typeparam name="T">The type of build the serializer for.</typeparam>
public static void Build<T>()
{
var type = typeof(T);
Build(type);
}
/// <summary>
/// Build the ProtoBuf serializer from the data's <see cref="Type">type</see>.
/// </summary>
/// <typeparam name="T">The type of build the serializer for.</typeparam>
/// <param name="data">The data who's type a serializer will be made.</param>
// ReSharper disable once UnusedParameter.Global
public static void Build<T>(T data)
{
Build<T>();
}
/// <summary>
/// Build the ProtoBuf serializer for the <see cref="Type">type</see>.
/// </summary>
/// <param name="type">The type of build the serializer for.</param>
public static void Build(Type type)
{
if (BuiltTypes.Contains(type))
{
return;
}
lock (type)
{
if (RuntimeTypeModel.Default.CanSerialize(type))
{
if (type.IsGenericType)
{
BuildGenerics(type);
}
return;
}
var meta = RuntimeTypeModel.Default.Add(type, false);
var fields = GetFields(type);
meta.Add(fields.Select(m => m.Name).ToArray());
meta.UseConstructor = false;
BuildBaseClasses(type);
BuildGenerics(type);
foreach (var memberType in fields.Select(f => f.FieldType).Where(t => !t.IsPrimitive))
{
Build(memberType);
}
BuiltTypes.Add(type);
}
}
/// <summary>
/// Gets the fields for a type.
/// </summary>
/// <param name="type">The type.</param>
/// <returns></returns>
private static FieldInfo[] GetFields(Type type)
{
return type.GetFields(Flags);
}
/// <summary>
/// Builds the base class serializers for a type.
/// </summary>
/// <param name="type">The type.</param>
private static void BuildBaseClasses(Type type)
{
var baseType = type.BaseType;
var inheritingType = type;
while (baseType != null && baseType != ObjectType)
{
HashSet<Type> baseTypeEntry;
if (!SubTypes.TryGetValue(baseType, out baseTypeEntry))
{
baseTypeEntry = new HashSet<Type>();
SubTypes.Add(baseType, baseTypeEntry);
}
if (!baseTypeEntry.Contains(inheritingType))
{
Build(baseType);
RuntimeTypeModel.Default[baseType].AddSubType(baseTypeEntry.Count + 500, inheritingType);
baseTypeEntry.Add(inheritingType);
}
inheritingType = baseType;
baseType = baseType.BaseType;
}
}
/// <summary>
/// Builds the serializers for the generic parameters for a given type.
/// </summary>
/// <param name="type">The type.</param>
private static void BuildGenerics(Type type)
{
if (type.IsGenericType || (type.BaseType != null && type.BaseType.IsGenericType))
{
var generics = type.IsGenericType ? type.GetGenericArguments() : type.BaseType.GetGenericArguments();
foreach (var generic in generics)
{
Build(generic);
}
}
}
}
}
|
