public bool HandlesMessage(IInterDomainMessage message)
{
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)message;
bool ret = false;
lock (_myRoutes)
{
foreach (sRoute srt in ridm.HandlerRoutes)
{
if (_myRoutes.Contains(srt))
{
ret = true;
break;
}
}
}
if (!ret)
{
lock (_subRoutes)
{
foreach (sRoute srt in ridm.HandlerRoutes)
{
if (_subRoutes.ContainsKey(srt))
{
ret = true;
break;
}
}
}
}
return(ret);
}
public void InterceptResponse(ref Messages.InterDomainMessageResponse response)
{
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)response.Message;
lock (_postRequestors)
{
foreach (sRoute srt in ridm.PostInterceptRoutes)
{
if (_postRequestors.ContainsKey(srt))
{
foreach (IInterDomainMessagePostRequestInterceptor idmpri in _postRequestors[srt])
{
if (!response.HasIntercepted(idmpri.GetType()))
{
object tmp;
idmpri.InterceptResponse(response, out tmp);
if (tmp != null)
{
response = Messages.InterDomainMessageResponse.SwapResponse(response, tmp);
response.MarkInterceptor(idmpri.GetType());
}
}
}
}
}
}
}
public object ProcessMessage(IInterDomainMessage message)
{
object ret = null;
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)message;
lock (_handlers)
{
foreach (sRoute srt in ridm.HandlerRoutes)
{
if (_handlers.ContainsKey(srt))
{
foreach (IInterDomainMessageHandler idmh in _handlers[srt])
{
try
{
ret = idmh.ProcessMessage(ridm);
break;
}
catch (Exception e)
{
System.Error(e);
ret = null;
}
}
if (ret != null)
{
break;
}
}
}
}
return(ret);
}
public IInterDomainMessage InterceptMessage(IInterDomainMessage message)
{
IInterDomainMessage ret = message;
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)message;
List <Core> subCores = new List <Core>();
lock (_myRoutes)
{
foreach (sRoute srt in ridm.PreInterceptRoutes)
{
if (_myRoutes.Contains(srt))
{
if (_messageController.InterceptsMessage(ridm))
{
subCores.Add(this);
}
break;
}
}
}
lock (_subRoutes)
{
foreach (sRoute srt in ridm.PreInterceptRoutes)
{
if (_subRoutes.ContainsKey(srt))
{
foreach (Core cr in _subRoutes[srt])
{
if (!subCores.Contains(cr))
{
subCores.Add(cr);
}
}
}
}
}
foreach (Core cr in subCores)
{
try
{
ret = cr.InterceptMessage(ret);
}
catch (Exception e) { }
}
return(ret);
}
public InterDomainMessageResponse ProcessMessage(IInterDomainMessage message)
{
InterDomainMessageResponse ret = null;
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)message;
lock (_myRoutes)
{
foreach (sRoute srt in ridm.HandlerRoutes)
{
if (_myRoutes.Contains(srt))
{
if (_messageController.HandlesMessage(ridm))
{
ret = new InterDomainMessageResponse(ridm, _messageController.ProcessMessage(ridm));
break;
}
}
}
}
if (ret == null)
{
lock (_subRoutes)
{
foreach (sRoute srt in ridm.HandlerRoutes)
{
if (_subRoutes.ContainsKey(srt))
{
foreach (Core cr in _subRoutes[srt])
{
if (cr.HandlesMessage(ridm))
{
ret = cr.ProcessMessage(ridm);
break;
}
}
if (ret != null)
{
break;
}
}
}
}
}
return(ret);
}
public bool InterceptsResponse(Messages.InterDomainMessageResponse response)
{
bool ret = false;
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)response.Message;
lock (_postRequestors)
{
foreach (sRoute srt in ridm.PostInterceptRoutes)
{
if (_postRequestors.ContainsKey(srt))
{
ret = true;
break;
}
}
}
return(ret);
}
public bool InterceptsMessage(IInterDomainMessage message)
{
bool ret = false;
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)message;
lock (_preRequestors)
{
foreach (sRoute srt in ridm.PreInterceptRoutes)
{
if (_preRequestors.ContainsKey(srt))
{
ret = true;
break;
}
}
}
return(ret);
}
public static InterDomainMessageResponse ProcessInterDomainMessage(IInterDomainMessage message)
{
DateTime start = DateTime.Now;
message = new RoutedInterDomainMessage(message);
message = _core.AbsoluteParent.InterceptMessage(message);
Debug("Time to intercept interdomain message {0}:{1}ms", message.Name, DateTime.Now.Subtract(start).TotalMilliseconds);
start = DateTime.Now;
InterDomainMessageResponse ret = _core.AbsoluteParent.ProcessMessage(message);
Debug("Time to handle interdomain message {0}:{1}ms", message.Name, DateTime.Now.Subtract(start).TotalMilliseconds);
start = DateTime.Now;
if (ret != null)
{
_core.AbsoluteParent.InterceptResponse(ref ret);
Debug("Time to intercept interdomain response {0}:{1}ms", message.Name, DateTime.Now.Subtract(start).TotalMilliseconds);
}
return(ret);
}
public void InterceptResponse(ref InterDomainMessageResponse response)
{
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)response.Message;
lock (_myRoutes)
{
foreach (sRoute srt in ridm.PostInterceptRoutes)
{
if (_myRoutes.Contains(srt))
{
if (_messageController.InterceptsResponse(response))
{
_messageController.InterceptResponse(ref response);
}
break;
}
}
}
List <Core> subCores = new List <Core>();
lock (_subRoutes)
{
foreach (sRoute srt in ridm.PostInterceptRoutes)
{
if (_subRoutes.ContainsKey(srt))
{
foreach (Core cr in _subRoutes[srt])
{
if (!subCores.Contains(cr))
{
subCores.Add(cr);
}
}
}
}
foreach (Core cr in subCores)
{
cr.InterceptResponse(ref response);
}
}
}
public IInterDomainMessage InterceptMessage(IInterDomainMessage message)
{
IInterDomainMessage ret = message;
RoutedInterDomainMessage ridm = (RoutedInterDomainMessage)message;
lock (_preRequestors)
{
foreach (sRoute srt in ridm.PreInterceptRoutes)
{
if (_preRequestors.ContainsKey(srt))
{
foreach (IInterDomainMessagePreRequestInterceptor iidmpri in _preRequestors[srt])
{
ret = iidmpri.InterceptMessage(ret);
}
break;
}
}
}
return(new RoutedInterDomainMessage(ridm, ret));
}
