private void MergeInto(CallbackSemantics semantics, CallbackOptions option) { if (IsSpecified(option) && !semantics.IsSpecified(option)) { semantics.SetOption(option, HasOption(option)); } }
public void MergeInto(CallbackSemantics semantics) { MergeInto(semantics, CallbackOptions.Duck); MergeInto(semantics, CallbackOptions.Strict); MergeInto(semantics, CallbackOptions.Resolve); MergeInto(semantics, CallbackOptions.BestEffot); MergeInto(semantics, CallbackOptions.Broadcast); }
public HandleMethod(Type protocol, IMethodMessage methodCall, CallbackSemantics semantics = null) { _semantics = semantics; Method = (MethodInfo)methodCall.MethodBase; Arguments = methodCall.Args; Protocol = protocol ?? Method.ReflectedType; ResultType = Method.ReturnType == typeof(void) ? null : Method.ReturnType; }
object IProtocolAdapter.Dispatch(Type protocol, IMethodCallMessage message) { IHandler handler = this; protocol = protocol ?? message.MethodBase.ReflectedType; var options = CallbackOptions.None; var semantics = new CallbackSemantics(); handler.Handle(semantics, true); if (!semantics.IsSpecified(CallbackOptions.Duck) && typeof(IDuck).IsAssignableFrom(protocol)) { options |= CallbackOptions.Duck; } if (!semantics.IsSpecified(CallbackOptions.Strict) && typeof(IStrict).IsAssignableFrom(protocol)) { options |= CallbackOptions.Strict; } if (!semantics.IsSpecified(CallbackOptions.Resolve) && typeof(IResolving).IsAssignableFrom(protocol)) { options |= CallbackOptions.Resolve; } if (options != CallbackOptions.None) { semantics.SetOption(options, true); handler = this.Semantics(options); } var broadcast = semantics.HasOption(CallbackOptions.Broadcast); var handleMethod = new HandleMethod(protocol, message, semantics); var callback = semantics.HasOption(CallbackOptions.Resolve) ? new ResolveMethod(protocol, broadcast, handleMethod) : (object)handleMethod; var handled = handler.Handle(callback, broadcast); if (!(handled || semantics.HasOption(CallbackOptions.BestEffot))) { throw new MissingMethodException( $"Method '{message.MethodName}' on {message.TypeName} not handled"); } var result = handleMethod.Result; return(handled || result != null ? result : RuntimeHelper.GetDefault(handleMethod.ResultType)); }
protected override bool HandleCallback( object callback, bool greedy, IHandler composer) { var handled = false; if (Composition.IsComposed <CallbackSemantics>(callback)) { return(false); } var semantics = callback as CallbackSemantics; if (semantics != null) { _semantics.MergeInto(semantics); handled = true; } else if (!greedy) { if (_semantics.IsSpecified(CallbackOptions.Broadcast)) { greedy = _semantics.HasOption(CallbackOptions.Broadcast); } else { var cs = new CallbackSemantics(); if (Handle(cs, true) && cs.IsSpecified(CallbackOptions.Broadcast)) { greedy = cs.HasOption(CallbackOptions.Broadcast); } } } if (greedy || !handled) { handled = base.HandleCallback(callback, greedy, composer) || handled; } return(handled); }
public SemanticsHandler( IHandler handler, CallbackOptions options) : base(handler) { _semantics = new CallbackSemantics(options); }