/// <summary>
/// Ctor.
/// </summary>
/// <param name="agentInstanceHandle">is a statement handle</param>
/// <param name="callback">is a schedule callback</param>
public EPStatementHandleCallbackSchedule(
EPStatementAgentInstanceHandle agentInstanceHandle,
ScheduleHandleCallback callback)
{
this.agentInstanceHandle = agentInstanceHandle;
this.scheduleCallback = callback;
}
public static Object NewInstance(String engineURI, String statementName, ScheduleHandleCallback scheduleHandleCallback)
{
var generator = new ProxyGenerator();
return(generator.CreateInterfaceProxyWithoutTarget(
typeof(ScheduleHandleCallback),
scheduleHandleCallback.GetType().GetInterfaces(),
new ScheduleHandleCallbackProxy(engineURI, statementName, scheduleHandleCallback)));
}
/// <summary>
/// Processing multiple schedule matches for a statement.
/// </summary>
/// <param name="handle">statement handle</param>
/// <param name="callbackObject">object containing matches</param>
/// <param name="services">runtime services</param>
public static void ProcessStatementScheduleMultiple(
EPStatementAgentInstanceHandle handle,
object callbackObject,
EPServicesEvaluation services)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QTimeCP(handle, services.SchedulingService.Time);
}
handle.StatementAgentInstanceLock.AcquireWriteLock();
try {
if (!handle.IsDestroyed)
{
if (handle.HasVariables)
{
services.VariableManagementService.SetLocalVersion();
}
if (callbackObject is ArrayDeque <ScheduleHandleCallback> )
{
ArrayDeque <ScheduleHandleCallback> callbackList = (ArrayDeque <ScheduleHandleCallback>)callbackObject;
foreach (ScheduleHandleCallback callback in callbackList)
{
callback.ScheduledTrigger();
}
}
else
{
ScheduleHandleCallback callback = (ScheduleHandleCallback)callbackObject;
callback.ScheduledTrigger();
}
// internal join processing, if applicable
handle.InternalDispatch();
}
}
catch (Exception ex) {
services.ExceptionHandlingService.HandleException(ex, handle, ExceptionHandlerExceptionType.PROCESS, null);
}
finally {
if (handle.HasTableAccess)
{
services.TableExprEvaluatorContext.ReleaseAcquiredLocks();
}
handle.StatementAgentInstanceLock.ReleaseWriteLock();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().ATimeCP();
}
}
}
public static void EvaluateSchedule(SchedulingService service)
{
ICollection <ScheduleHandle> handles = new LinkedList <ScheduleHandle>();
service.Evaluate(handles);
foreach (ScheduleHandle handle in handles)
{
if (handle is EPStatementHandleCallback)
{
EPStatementHandleCallback callback = (EPStatementHandleCallback)handle;
callback.ScheduleCallback.ScheduledTrigger(null);
}
else
{
ScheduleHandleCallback cb = (ScheduleHandleCallback)handle;
cb.ScheduledTrigger(null);
}
}
}
public ScheduleHandleCallbackProxy(String engineURI, String statementName, ScheduleHandleCallback scheduleHandleCallback)
{
_engineURI = engineURI;
_statementName = statementName;
_scheduleHandleCallback = scheduleHandleCallback;
}
/// <summary>Ctor. </summary>
/// <param name="agentInstanceHandle">is a statement handle</param>
/// <param name="callback">is a schedule callback</param>
public EPStatementHandleCallback(EPStatementAgentInstanceHandle agentInstanceHandle, ScheduleHandleCallback callback)
{
_agentInstanceHandle = agentInstanceHandle;
_scheduleCallback = callback;
}
public static ScheduleHandleCallback NewInstance(String engineURI, String statementName, ScheduleHandleCallback scheduleHandleCallback)
{
var generator = new ProxyGenerator();
var interfaces = scheduleHandleCallback
.GetType()
.GetInterfaces()
.Where(ii => ii != typeof(IProxyTargetAccessor))
.ToArray();
return((ScheduleHandleCallback)generator.CreateInterfaceProxyWithoutTarget(
typeof(ScheduleHandleCallback), interfaces, new ScheduleHandleCallbackProxy(engineURI, statementName, scheduleHandleCallback)));
}
