blob: d0e7c11adc74285cb652c46264d934bc6a111efd (
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
using System;
using System.Reflection;
namespace ProtoBuf.Meta
{
public class CallbackSet
{
internal MethodInfo this[TypeModel.CallbackType callbackType]
{
get
{
MethodInfo result;
switch (callbackType)
{
case TypeModel.CallbackType.BeforeSerialize:
result = this.beforeSerialize;
break;
case TypeModel.CallbackType.AfterSerialize:
result = this.afterSerialize;
break;
case TypeModel.CallbackType.BeforeDeserialize:
result = this.beforeDeserialize;
break;
case TypeModel.CallbackType.AfterDeserialize:
result = this.afterDeserialize;
break;
default:
throw new ArgumentException("Callback type not supported: " + callbackType.ToString(), "callbackType");
}
return result;
}
}
public MethodInfo BeforeSerialize
{
get
{
return this.beforeSerialize;
}
set
{
this.beforeSerialize = this.SanityCheckCallback(this.metaType.Model, value);
}
}
public MethodInfo BeforeDeserialize
{
get
{
return this.beforeDeserialize;
}
set
{
this.beforeDeserialize = this.SanityCheckCallback(this.metaType.Model, value);
}
}
public MethodInfo AfterSerialize
{
get
{
return this.afterSerialize;
}
set
{
this.afterSerialize = this.SanityCheckCallback(this.metaType.Model, value);
}
}
public MethodInfo AfterDeserialize
{
get
{
return this.afterDeserialize;
}
set
{
this.afterDeserialize = this.SanityCheckCallback(this.metaType.Model, value);
}
}
public bool NonTrivial
{
get
{
return this.beforeSerialize != null || this.beforeDeserialize != null || this.afterSerialize != null || this.afterDeserialize != null;
}
}
private readonly MetaType metaType;
private MethodInfo beforeSerialize;
private MethodInfo afterSerialize;
private MethodInfo beforeDeserialize;
private MethodInfo afterDeserialize;
internal CallbackSet(MetaType metaType)
{
bool flag = metaType == null;
if (flag)
{
throw new ArgumentNullException("metaType");
}
this.metaType = metaType;
}
internal static bool CheckCallbackParameters(TypeModel model, MethodInfo method)
{
ParameterInfo[] parameters = method.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
Type parameterType = parameters[i].ParameterType;
bool flag = parameterType == model.MapType(typeof(SerializationContext));
if (!flag)
{
bool flag2 = parameterType == model.MapType(typeof(Type));
if (!flag2)
{
return false;
}
}
}
return true;
}
private MethodInfo SanityCheckCallback(TypeModel model, MethodInfo callback)
{
this.metaType.ThrowIfFrozen();
bool flag = callback == null;
MethodInfo result;
if (flag)
{
result = callback;
}
else
{
bool isStatic = callback.IsStatic;
if (isStatic)
{
throw new ArgumentException("Callbacks cannot be static", "callback");
}
bool flag2 = callback.ReturnType != model.MapType(typeof(void)) || !CallbackSet.CheckCallbackParameters(model, callback);
if (flag2)
{
throw CallbackSet.CreateInvalidCallbackSignature(callback);
}
result = callback;
}
return result;
}
internal static Exception CreateInvalidCallbackSignature(MethodInfo method)
{
return new NotSupportedException("Invalid callback signature in " + method.DeclaringType.FullName + "." + method.Name);
}
}
}
|
