public RouteAction Handle(ICall call) { var callSpecification = _callSpecificationFactory.CreateFrom(call, _matchArgs); if (!_receivedCalls.FindMatchingCalls(callSpecification).Any()) { _exceptionThrower.Throw(callSpecification, GetAllReceivedCallsToMethod(call)); } return RouteAction.Continue(); }
public bool IsTriggered(ICall call, DateTime triggerDate) { if( new TimeSpan(triggerDate.Ticks - call.Date.Ticks).TotalMilliseconds >= _delay) return true; return false; }
RouteAction ICallHandler.Handle(ICall call) { if (!HasResultFor(call)) action(); return RouteAction.Continue(); }
public bool IsSatisfiedBy(ICall call) { if (_methodInfo != call.GetMethodInfo()) return false; if (HasDifferentNumberOfArguments(call)) return false; if (NonMatchingArguments(call).Any()) return false; return true; }
public object GetResult(ICall call) { return _results .Reverse() .First(x => x.IsResultFor(call)) .GetResult(_callInfoFactory.Create(call)); }
public RouteAction Handle(ICall call) { var target = call.Target(); var callSpec = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall); _context.AddToQuery(target, callSpec); return RouteAction.Continue(); }
public void Expect( ICall call ) { if ( expectedCalls == null ) expectedCalls = new ArrayList(); expectedCalls.Add( call ); }
private ICode HandleCall(ICall call, Func<Expr, IEnumerable<Expr>, ICode> fnNew) { if (call.CallMethod.Name == "DeepCopyValueType") { // HACK return call; } var obj = (Expr)this.Visit(call.Obj); var argsInfo = call.Args.Select((arg, i) => new { arg, parameterType = call.CallMethod.Parameters[i].ParameterType }).ToArray(); var args = this.HandleList(argsInfo, argInfo => { if (!argInfo.parameterType.IsValueType) { return argInfo; } var arg = argInfo.arg; var type = arg.Type; if (type.IsNonPrimitiveValueType() && !type.IsRuntimeHandle() && !type.IsEnum()) { return new { arg = InternalFunctions.ValueTypeDeepCopyIfRequired(arg.Type, () => arg) ?? arg, parameterType = argInfo.parameterType }; } else { return argInfo; } }).NullThru(x => x.Select(y => y.arg).ToArray()); if (obj != call.Obj || args != null) { return fnNew(obj, args ?? call.Args); } else { return call; } }
public static Expr op_Equality(ICall call) { var ctx = call.Ctx; var a = call.Args.ElementAt(0); var b = call.Args.ElementAt(1); var expr = new ExprBinary(ctx, BinaryOp.Equal, ctx.Boolean, a, b); return expr; }
public RouteAction Handle(ICall call) { var callSpec = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall); _pendingCallSpecification.Set(callSpec); _callActions.Add(callSpec); return RouteAction.Continue(); }
public IEnumerable<ArgumentMatchInfo> NonMatchingArguments(ICall call) { var arguments = call.GetArguments(); return arguments .Select((arg, index) => new ArgumentMatchInfo(index, arg, _argumentSpecifications[index])) .Where(x => !x.IsMatch); }
public bool TriggeredExecution(ICall call) { foreach(ITrigger trigger in _triggers) { if(!trigger.IsTriggered(call, DateTime.Now)) return false; } _log.Info("Actionpack '{0}' is triggered for call '{1}'", _name, call); foreach(IAction action in _actions) { try { _log.Info("started action '{0}'", action.GetType()); action.Execute(call); _log.Info("Completed action '{0}'", action.GetType()); } catch(Exception e) { _log.ErrorException(string.Format("Error executing action '{0}'",action.GetType()), e); } } return true; }
public void OnFailure(ICall call, Java.IO.IOException exception) { if (onFailure != null) { onFailure(call, exception); } }
public void OnResponse(ICall call, Response response) { if (onResponse != null) { onResponse(call, response); } }
public void InvokeMatchingActions(ICall call) { var callInfo = _callInfoFactory.Create(call); foreach (var action in _actions.Where(x => x.IsSatisfiedBy(call))) { action.Invoke(callInfo); } }
public RouteAction Handle(ICall call) { if (_callResults.HasResultFor(call)) { return RouteAction.Return(_callResults.GetResult(call)); } return RouteAction.Continue(); }
public object Handle(ICall call) { _routeParts.GetPart<EventSubscriptionHandler>().Handle(call); _routeParts.GetPart<PropertySetterHandler>().Handle(call); _routeParts.GetPart<DoActionsCallHandler>().Handle(call); _routeParts.GetPart<RecordCallHandler>().Handle(call); return _routeParts.GetPart<ReturnConfiguredResultHandler>().Handle(call); }
public RouteAction Handle(ICall call) { var type = call.GetReturnType(); var compatibleProviders = _autoValueProviders.Where(x => x.CanProvideValueFor(type)).FirstOrNothing(); return compatibleProviders.Fold( RouteAction.Continue, ReturnValueUsingProvider(call, type)); }
public DtmfEventArgs(ICall call, int digit) { Helper.GuardNotNull(call); Helper.GuardPositiveInt(call.Id); Digit = Convert.ToChar(digit); CallId = call.Id; }
public RouteAction Handle(ICall call) { // We want the proxies to respond to the base object methods (e.g. Equals, GetHashCode) if (call.GetMethodInfo().GetBaseDefinition().DeclaringType == typeof(object)) return RouteAction.Return(call.CallOriginalMethod()); return RouteAction.Continue(); }
private void If(ICall call, Func<ICall, Predicate<EventInfo>> meetsThisSpecification, Action<string, object> takeThisAction) { var events = GetEvents(call, meetsThisSpecification); if (events.Any()) { takeThisAction(events.First().Name, call.GetArguments()[0]); } }
public RingEventArgs(bool ringOn, ICall call) { Helper.GuardNotNull(call); Helper.GuardPositiveInt(call.Id); RingOn = ringOn; IsRingback = !call.IsIncoming; CallId = call.Id; }
private string FormatCall(ICall call, bool isAcrossMultipleTargets, TypeInstanceNumberLookup instanceLookup) { var s = _callFormatter.Format(call.GetMethodInfo(), FormatArgs(call.GetArguments())); if (!isAcrossMultipleTargets) return s; var target = call.Target(); var methodInfo = call.GetMethodInfo(); return FormatCallForInstance(instanceLookup, target, methodInfo, s); }
private Func<IAutoValueProvider, RouteAction> ReturnValueUsingProvider(ICall call, Type type) { return provider => { var valueToReturn = provider.GetValue(type); ConfigureCall.SetResultForCall(call, new ReturnValue(valueToReturn), MatchArgs.AsSpecifiedInCall); return RouteAction.Return(valueToReturn); }; }
public IEnumerable<int> NonMatchingArgumentIndicies(ICall call) { var arguments = call.GetArguments(); for (var i = 0; i < arguments.Length; i++) { var argumentMatchesSpecification = ArgIsSpecifiedAndMatchesSpec(arguments[i], i); if (!argumentMatchesSpecification) yield return i; } }
public RouteAction Handle(ICall call) { if (!_required) return RouteAction.Continue(); if (_callBaseExclusions.IsExcluded(call)) return RouteAction.Continue(); return call .TryCallBase() .Fold(RouteAction.Continue, RouteAction.Return); }
public ICallSpecification CreateFrom(ICall call, MatchArgs matchArgs) { var methodInfo = call.GetMethodInfo(); var argumentSpecs = call.GetArgumentSpecifications(); var arguments = call.GetOriginalArguments(); var parameterInfos = call.GetParameterInfos(); var argumentSpecificationsForCall = _argumentSpecificationsFactory.Create(argumentSpecs, arguments, parameterInfos, matchArgs); return new CallSpecification(methodInfo, argumentSpecificationsForCall); }
public ICall CreateCallToPropertyGetterFromSetterCall(ICall callToSetter) { var propertyInfo = GetPropertyFromSetterCallOrNull(callToSetter); if (!PropertySetterExistsAndHasAGetMethod(propertyInfo)) { throw new InvalidOperationException("Could not find a GetMethod for \"" + callToSetter.GetMethodInfo() + "\""); } var getter = propertyInfo.GetGetMethod(); return new CallToPropertyGetter(getter, callToSetter.Target()); }
public object Route(ICall call) { _context.LastCallRouter(this); if (_context.IsQuerying) { UseQueryRouteForNextCall(); } else if (IsSpecifyingACall(call)) { UseRecordCallSpecRouteForNextCall(); } var routeToUseForThisCall = _currentRoute; UseDefaultRouteForNextCall(); return routeToUseForThisCall.Handle(call); }
public object Handle(ICall call) { var actions = _callActions.MatchingActions(call); var callInfo = _callInfoFactory.Create(call); foreach (var action in actions) { action(callInfo); } return null; }
public RouteAction Handle(ICall call) { call.AssignSequenceNumber(_generator.Next()); _callCollection.Add(call); return(RouteAction.Continue()); }
public bool IsResultFor(ICall call) => _callSpecification.IsSatisfiedBy(call);
public override void OnCallStarted(ICall call) { Log.Debug(TAG, "OnCallStarted " + call); }
private PropertyInfo GetPropertyFromSetterCallOrNull(ICall call) { return(call.GetMethodInfo().GetPropertyFromSetterCallOrNull()); }
/// <summary> /// Event fired when call has been updated. /// </summary> /// <param name="sender">Call object.</param> /// <param name="args">Event args containing the old values and the new values.</param> private void CallOnUpdated(ICall sender, ResourceEventArgs <Call> args) { var outcome = Serializer.SerializeObject(sender.Resource); this.OutcomesLogMostRecentFirst.AddFirst("Call Updated:\n" + outcome); }
public AppPoolWatcher(ICall call, IEmail email, ISMS sms) { this.call = call; this.email = email; this.sms = sms; }
public void Esclate(ICall call) { }
public void OnFailure(ICall p0, Throwable p1) { }
public CallWrapper(ICall call) { Call = call; }
public ClientMethodInvoker(ICall call) { _call = call; }
public override void Context() { _call = mock <ICall>(); _callResults = mock <ICallResults>(); }
static async ValueTask <T> SlowExecuteValueCall(SingleThreadInvoker @this, ICall <T> call) { await @this.WaitForExecutionSlot(); try { return(await call.Invoke()); } finally { @this.ReturnExecutionSlot(); } }
public void Delete() { Call = null; }
private void Call(ICall call) { SimCardHolder.Call(call); }
protected abstract object?[] WorkOutRequiredArguments(ICall call);
public async Task DoStep(Step settings, ICall call) { call.Logger.Info($"Stop recording {call.CallState.GetIncomingLineId()}"); await call.RecordingManager.StopRecordingOnLine(call.CallState.GetIncomingLineId()); }
public void ProcessCall(ICall call) { call.Status = CallStatus.Processing; Console.WriteLine($"Manager: {this.EmployeeID} is Prcessing call {call.CallID}"); call.Status = CallStatus.Accomplished; }
private void Connect() { DebugLog.AddEntry("connecting..."); // create network config if (networkConfig == null) { networkConfig = CreateNetworkConfig(account); } // setup caller caller = UnityCallFactory.Instance.Create(networkConfig); if (caller == null) { Debug.Log("Failed to create caller"); return; } caller.LocalFrameEvents = true; caller.CallEvent += HandleCallEvent; // setup media config if (mediaConfig == null) { mediaConfig = CreateMediaConfig(); // prefer the external video device if (UnityCallFactory.Instance.CanSelectVideoDevice()) { string[] videoDevices = UnityCallFactory.Instance.GetVideoDevices(); // show all video device names for (int i = 0; i < videoDevices.Length; i++) { var name = videoDevices[i]; DebugLog.AddEntry("video device #" + i + ": " + name); } var preferredDevice = PlayerPrefs.GetInt(PREFS.VIDEO_DEVICE); if (preferredDevice < videoDevices.Length) { mediaConfig.VideoDeviceName = videoDevices[preferredDevice]; } else { // use defualt device if the preferred device is out of range mediaConfig.VideoDeviceName = videoDevices[0]; } } else { mediaConfig.VideoDeviceName = UnityCallFactory.Instance.GetDefaultVideoDevice(); } DebugLog.AddEntry("Using video device: " + mediaConfig.VideoDeviceName); } caller.Configure(mediaConfig); // start listening... if (Globals.role == Role.Therapist) { DebugLog.AddEntry("server listening for connections on " + account.address + "..."); SetStatusMessageText("Listening for connections on " + account.address + "..."); caller.Listen(account.address); } else { DebugLog.AddEntry("client connecting to " + account.address + "..."); SetStatusMessageText("Connecting to " + account.address + "..."); caller.Call(account.address); } }
public bool IsSatisfiedBy(ICall call) { return(_callSpecification.IsSatisfiedBy(call)); }
public CallStateMachine(ICall call, IPromptPlayer promptPlayer) { _call = call; _promptPlayer = promptPlayer; }
public void OnResponse(ICall p0, Response p1) { tcs.TrySetResult(p1); }
private static bool NotCompleteMethod(ICall call) { return(call.GetMethodInfo().Name != "Complete"); }
/// <summary> /// Gets the request rquid from the call if it exists. /// Otherwise it creates and sets it. /// </summary> protected string GetRequestRquId(ICall call) { return(GeneralUtility.GetRequestRquId(call)); }
public MyConsole() { m_items.Add("test", ICall.Create(Test)); }
public override void OnCallEndedWithError(ICall call, CallException callException) { Log.Debug(TAG, "OnCallEndedWithError " + call); }
public IMessageBuilder InDialogOf(ICall call) { Helper.GuardNotNull(call); _dialog = call; return(this); }
private static bool ReturnsVoidFrom(ICall call) { return(call.GetReturnType() == typeof(void)); }
public void Push(ICall call) { _stack.Push(call); }
public RouteAction Handle(ICall call) => _handler.Invoke(call);
/// <inheritdoc/> protected override void CallOnUpdated(ICall sender, ResourceEventArgs <Call> args) { this.statusData?.UpdateBotMeetingStatus(sender.Resource.State); }