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 RouteAction Handle(ICall call)
 {
     var target = call.Target();
     var callSpec = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall);
     _context.AddToQuery(target, callSpec);
     return RouteAction.Continue();
 }

        RouteAction ICallHandler.Handle(ICall call)
        {
            if (!HasResultFor(call))
                action();

            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);
 }

 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 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 bool IsTriggered(ICall call, DateTime triggerDate)
		{
			if( new TimeSpan(triggerDate.Ticks - call.Date.Ticks).TotalMilliseconds >= _delay)
				return true;
			
			return false;
		}

 public RouteAction Handle(ICall call)
 {
     var callSpec = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall);
     _pendingCallSpecification.Set(callSpec);
     _callActions.Add(callSpec);
     return RouteAction.Continue();
 }

 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 void Expect( ICall call )
		{
			if ( expectedCalls == null )
				expectedCalls = new ArrayList();

			expectedCalls.Add( call );
		}

		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 RingEventArgs(bool ringOn, ICall call)
 {
     Helper.GuardNotNull(call);
     Helper.GuardPositiveInt(call.Id);
     RingOn = ringOn;
     IsRingback = !call.IsIncoming;
     CallId = call.Id;
 }