private static void SubscribeTokens <T, TAttr>(IComponentInfoRpcProvider <T> provider, byte compId, IEnumerable <KeyValuePair <byte?, TAttr> > tokens, Func <NetMessage, T, object> fncDel)
where TAttr : Attribute, IRpcAttribute
{
foreach (var token in tokens)
{
if (token.Value == null)
{
continue;
}
provider.SubscribeToFunc(token.Key.HasValue ? token.Key.Value : compId, token.Value.RpcId, fncDel);
}
}
private static void SubscribeTokens <T, TAttr>(IComponentInfoRpcProvider <T> provider, byte compId, IEnumerable <KeyValuePair <byte?, TAttr> > tokens,
Action <NetMessage, T> del) where TAttr : Attribute, IRpcAttribute
{
foreach (var token in tokens)
{
if (token.Value == null)
{
continue;
}
provider.SubscribeToRpc(token.Key.HasValue ? token.Key.Value : compId, token.Value.RpcId, del, defaultContinueForwarding: token.Value.DefaultContinueForwarding);
}
}
/// <summary>
/// Subscribe TAttr marked methods on obj to the provider
/// </summary>
/// <typeparam name="TInfo"></typeparam>
/// <typeparam name="TAttr"></typeparam>
/// <param name="provider"></param>
/// <param name="obj"></param>
/// <param name="serializer"></param>
/// <param name="logger"></param>
public static void SubscribeComponent <TInfo, TAttr>(IComponentInfoRpcProvider <TInfo> provider, object obj,
SerializationManager serializer, ILogger logger) where TAttr : Attribute, IRpcAttribute
{
if (obj == null)
{
return;
}
if (provider == obj)
{
return;
}
var objType = obj.GetType();
//logger.Info("Subscribing " + obj);
byte compId;
if (!objType.GetNetId(out compId))
{
throw new Exception("Cannot subscribe type " + objType + " as it lacks the NetComponentAttribute");
}
ForEachRpc <TAttr>(objType, (method, parms, parmTypes, tokens) =>
{
var msgDel =
Delegate.CreateDelegate(typeof(Action <NetMessage, TInfo>), obj, method, false) as Action <NetMessage, TInfo>;
if (msgDel != null)
{
SubscribeTokens(provider, compId, tokens, msgDel);
return;
}
var fncDel =
Delegate.CreateDelegate(typeof(Func <NetMessage, TInfo, object>), obj, method, false)
as Func <NetMessage, TInfo, object>;
if (fncDel != null)
{
SubscribeTokens(provider, compId, tokens, fncDel);
return;
}
if (method.ReturnType == typeof(void))
{
//the function isn't a deserializer function, so attempt to make our own from INetSerializable/default serializers
if (!CheckParameterSerialization <TInfo>(serializer, method, parms, logger))
{
return;
}
var filterProviders = GetAttributes <IComponentRpcFilterProvider <TInfo> >(objType, method, parmTypes);
var filters = filterProviders.Select(fprov => fprov.Value.GetFilter(provider)).ToArray();
DynamicMethodDelegate pre;
RpcCallers.TryGetValue(method.MethodHandle, out pre);
//prevent the open delegate from needing a reference to this networkview?
var deser = new RpcDeserializer <TInfo>(method, obj, serializer, parmTypes, filters, pre);
msgDel = deser.Message;
SubscribeTokens(provider, compId, tokens, msgDel);
}
else
{
//method returns something, so it's a func processor
if (!CheckParameterSerialization <TInfo>(serializer, method, parms, logger))
{
return;
}
if (!serializer.CanSerialize(method.ReturnType))
{
logger.Error($"Tried to subscribe method {method} for rpc functions, but return type {method.ReturnType} cannot be serialized");
return;
}
DynamicMethodDelegate pre;
RpcCallers.TryGetValue(method.MethodHandle, out pre);
var deser = new RpcDeserializer <TInfo>(method, obj, serializer, parmTypes, @delegate: pre);
fncDel = deser.ReturnMessage;
SubscribeTokens(provider, compId, tokens, fncDel);
}
});
}
public IRpcFilter <NetMessageInfo> GetFilter(IComponentInfoRpcProvider <NetMessageInfo> provider)
{
return(new OwnerFilter((provider as NetworkView)));
}
