/// <summary>
/// Add a filter callback according to the filter specification to the top node returning information to be used to remove the filter callback.
/// </summary>
/// <param name="filterValueSet">is the filter definition</param>
/// <param name="filterCallback">is the callback to be added</param>
/// <param name="topNode">node to be added to any subnode beneath it</param>
/// <param name="lockFactory">The lock factory.</param>
/// <returns>
/// an encapsulation of information need to allow for safe removal of the filter tree.
/// </returns>
public static ArrayDeque <EventTypeIndexBuilderIndexLookupablePair>[] Add(
FilterValueSet filterValueSet,
FilterHandle filterCallback,
FilterHandleSetNode topNode,
FilterServiceGranularLockFactory lockFactory)
{
if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled))
{
Log.Debug(".add (" + Thread.CurrentThread.ManagedThreadId + ") Adding filter callback, " +
" topNode=" + topNode +
" filterCallback=" + filterCallback);
}
ArrayDeque <EventTypeIndexBuilderIndexLookupablePair>[] treePathInfo;
if (filterValueSet.Parameters.Length == 0)
{
treePathInfo = AllocateTreePath(1);
treePathInfo[0] = new ArrayDeque <EventTypeIndexBuilderIndexLookupablePair>(1);
AddToNode(new ArrayDeque <FilterValueSetParam>(1), filterCallback, topNode, treePathInfo[0], lockFactory);
}
else
{
treePathInfo = AllocateTreePath(filterValueSet.Parameters.Length);
var remainingParameters = new ArrayDeque <FilterValueSetParam>(4);
for (int i = 0; i < filterValueSet.Parameters.Length; i++)
{
treePathInfo[i] = new ArrayDeque <EventTypeIndexBuilderIndexLookupablePair>(filterValueSet.Parameters[i].Length);
remainingParameters.Clear();
remainingParameters.AddAll(filterValueSet.Parameters[i]);
AddToNode(remainingParameters, filterCallback, topNode, treePathInfo[i], lockFactory);
}
}
return(treePathInfo);
}
public override FilterServiceEntry Add(FilterValueSet filterValueSet, FilterHandle callback)
{
using (_iLock.AcquireWriteLock())
{
return(base.AddInternal(filterValueSet, callback));
}
}
public void TestGetValueSet()
{
IList <FilterSpecParam> parameters = SupportFilterSpecBuilder.BuildList(_eventType, new Object[]
{ "IntPrimitive", FilterOperator.EQUAL, 2 });
var numberCoercer = CoercerFactory.GetCoercer(typeof(int), typeof(double));
parameters.Add(new FilterSpecParamEventProp(MakeLookupable("DoubleBoxed"), FilterOperator.EQUAL, "asName", "DoublePrimitive", false, numberCoercer, typeof(double?), "Test"));
FilterSpecCompiled filterSpec = new FilterSpecCompiled(_eventType, "SupportBean", new IList <FilterSpecParam>[] { parameters }, null);
SupportBean eventBean = new SupportBean();
eventBean.DoublePrimitive = 999.999;
EventBean theEvent = SupportEventBeanFactory.CreateObject(eventBean);
MatchedEventMap matchedEvents = new MatchedEventMapImpl(new MatchedEventMapMeta(new String[] { "asName" }, false));
matchedEvents.Add(0, theEvent);
FilterValueSet valueSet = filterSpec.GetValueSet(matchedEvents, null, null);
// Assert the generated filter value container
Assert.AreSame(_eventType, valueSet.EventType);
Assert.AreEqual(2, valueSet.Parameters[0].Length);
// Assert the first param
var param = valueSet.Parameters[0][0];
Assert.AreEqual("IntPrimitive", param.Lookupable.Expression);
Assert.AreEqual(FilterOperator.EQUAL, param.FilterOperator);
Assert.AreEqual(2, param.FilterForValue);
// Assert the second param
param = (FilterValueSetParam)valueSet.Parameters[0][1];
Assert.AreEqual("DoubleBoxed", param.Lookupable.Expression);
Assert.AreEqual(FilterOperator.EQUAL, param.FilterOperator);
Assert.AreEqual(999.999, param.FilterForValue);
}
protected FilterServiceEntry AddInternal(FilterValueSet filterValueSet, FilterHandle filterCallback)
{
var entry = _indexBuilder.Add(filterValueSet, filterCallback, _lockFactory);
_filtersVersion++;
return(entry);
}
private FilterValueSetParam[] GetFilterMulti(EPStatementSPI statementSPI)
{
var filterServiceSPI = (FilterServiceSPI)statementSPI.StatementContext.FilterService;
var set = filterServiceSPI.Take(Collections.SingletonList(statementSPI.StatementId));
Assert.AreEqual(1, set.Filters.Count);
FilterValueSet valueSet = set.Filters[0].FilterValueSet;
return(valueSet.Parameters[0]);
}
protected void StartFiltering()
{
FilterService filterService = _evalFilterNode.Context.PatternContext.FilterService;
Handle = new EPStatementHandleCallback(_evalFilterNode.Context.AgentInstanceContext.EpStatementAgentInstanceHandle, this);
FilterValueSet filterValues = _evalFilterNode.FactoryNode.FilterSpec.GetValueSet(BeginState, _evalFilterNode.Context.AgentInstanceContext, _evalFilterNode.AddendumFilters);
FilterServiceEntry = filterService.Add(filterValues, Handle);
long filtersVersion = filterService.FiltersVersion;
_evalFilterNode.Context.AgentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filtersVersion;
}
public void SetUp()
{
_eventTypeIndex = new EventTypeIndex(_lockFactory);
_indexBuilder = new EventTypeIndexBuilder(_eventTypeIndex, true);
_typeOne = SupportEventTypeFactory.CreateBeanType(typeof(SupportBean));
_typeTwo = SupportEventTypeFactory.CreateBeanType(typeof(SupportBeanSimple));
_valueSetOne = SupportFilterSpecBuilder.Build(_typeOne, new Object[0]).GetValueSet(null, null, null);
_valueSetTwo = SupportFilterSpecBuilder.Build(_typeTwo, new Object[0]).GetValueSet(null, null, null);
_callbackOne = new SupportFilterHandle();
_callbackTwo = new SupportFilterHandle();
}
public void SetUp()
{
_container = SupportContainer.Reset();
_lockFactory = new FilterServiceGranularLockFactoryReentrant(_container.RWLockManager());
_eventTypeIndex = new EventTypeIndex(_lockFactory);
_indexBuilder = new EventTypeIndexBuilder(_container.LockManager(), _eventTypeIndex, true);
_typeOne = SupportEventTypeFactory.CreateBeanType(typeof(SupportBean));
_typeTwo = SupportEventTypeFactory.CreateBeanType(typeof(SupportBeanSimple));
_valueSetOne = SupportFilterSpecBuilder.Build(_typeOne, new Object[0]).GetValueSet(null, null, null);
_valueSetTwo = SupportFilterSpecBuilder.Build(_typeTwo, new Object[0]).GetValueSet(null, null, null);
_callbackOne = new SupportFilterHandle();
_callbackTwo = new SupportFilterHandle();
}
/// <summary>
/// Add a filter to the event type index structure, and to the filter subtree.
/// Throws an IllegalStateException exception if the callback is already registered.
/// </summary>
/// <param name="filterValueSet">is the filter information</param>
/// <param name="filterCallback">is the callback</param>
/// <param name="lockFactory">The lock factory.</param>
/// <returns></returns>
/// <exception cref="IllegalStateException">Callback for filter specification already exists in collection</exception>
public FilterServiceEntry Add(FilterValueSet filterValueSet, FilterHandle filterCallback, FilterServiceGranularLockFactory lockFactory)
{
using (Instrument.With(
i => i.QFilterAdd(filterValueSet, filterCallback),
i => i.AFilterAdd()))
{
var eventType = filterValueSet.EventType;
// Check if a filter tree exists for this event type
var rootNode = _eventTypeIndex.Get(eventType);
// Make sure we have a root node
if (rootNode == null)
{
using (_callbacksLock.Acquire())
{
rootNode = _eventTypeIndex.Get(eventType);
if (rootNode == null)
{
rootNode = new FilterHandleSetNode(lockFactory.ObtainNew());
_eventTypeIndex.Add(eventType, rootNode);
}
}
}
// GetInstance add to tree
var path = IndexTreeBuilder.Add(filterValueSet, filterCallback, rootNode, lockFactory);
var pathArray = path.Select(p => p.ToArray()).ToArray();
var pair = new EventTypeIndexBuilderValueIndexesPair(filterValueSet, pathArray);
// for non-isolatable callbacks the consumer keeps track of tree location
if (_isolatableCallbacks == null)
{
return(pair);
}
// for isolatable callbacks this class is keeping track of tree location
using (_callbacksLock.Acquire()) {
_isolatableCallbacks.Put(filterCallback, pair);
}
return(null);
}
}
public void Activate(
EventBean optionalTriggeringEvent,
MatchedEventMap priorMatches,
long timeOffset,
bool isRecoveringResilient)
{
var filterCallback = new ProxyFilterHandleCallback
{
ProcStatementId = () => _agentInstanceContext.StatementContext.StatementId,
ProcMatchFound = (theEvent, allStmtMatches) => FilterMatchFound(theEvent),
ProcIsSubselect = () => false
};
// determine addendum, if any
FilterValueSetParam[][] addendum = null;
if (_filterAddendum != null)
{
addendum = _filterAddendum.GetFilterAddendum(_endpointFilterSpec.FilterSpecCompiled);
}
_filterHandle = new EPStatementHandleCallback(
_agentInstanceContext.EpStatementAgentInstanceHandle, filterCallback);
FilterValueSet filterValueSet = _endpointFilterSpec.FilterSpecCompiled.GetValueSet(
null, _agentInstanceContext, addendum);
_filterServiceEntry = _servicesContext.FilterService.Add(filterValueSet, _filterHandle);
long filtersVersion = _servicesContext.FilterService.FiltersVersion;
_agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
if (optionalTriggeringEvent != null)
{
bool match = StatementAgentInstanceUtil.EvaluateFilterForStatement(
_servicesContext, optionalTriggeringEvent, _agentInstanceContext, _filterHandle);
if (match)
{
FilterMatchFound(optionalTriggeringEvent);
}
}
}
public ContextControllerHashedFilterCallback(
EPServicesContext servicesContext,
AgentInstanceContext agentInstanceContextCreateContext,
ContextDetailHashItem hashItem,
ContextControllerHashedInstanceCallback callback,
ContextInternalFilterAddendum filterAddendum)
{
_agentInstanceContextCreateContext = agentInstanceContextCreateContext;
_callback = callback;
_getter = hashItem.Lookupable.Getter;
_filterHandle = new EPStatementHandleCallback(agentInstanceContextCreateContext.EpStatementAgentInstanceHandle, this);
FilterValueSetParam[][] addendum = filterAddendum != null?filterAddendum.GetFilterAddendum(hashItem.FilterSpecCompiled) : null;
FilterValueSet filterValueSet = hashItem.FilterSpecCompiled.GetValueSet(null, null, addendum);
_filterServiceEntry = servicesContext.FilterService.Add(filterValueSet, _filterHandle);
long filtersVersion = servicesContext.FilterService.FiltersVersion;
agentInstanceContextCreateContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filtersVersion;
}
/// <summary>Ctor. </summary>
/// <param name="handle">handle</param>
/// <param name="filterValueSet">values</param>
public FilterSetEntry(FilterHandle handle,
FilterValueSet filterValueSet)
{
Handle = handle;
FilterValueSet = filterValueSet;
}
public abstract FilterServiceEntry Add(FilterValueSet filterValueSet, FilterHandle callback);
public override FilterServiceEntry Add(FilterValueSet filterValueSet, FilterHandle callback)
{
return(base.AddInternal(filterValueSet, callback));
}
public void QFilterAdd(FilterValueSet filterValueSet, FilterHandle filterCallback)
{
}
public FilterServiceEntry Add(FilterValueSet filterValueSet, FilterHandle callback)
{
_added.Add(new Pair <FilterValueSet, FilterHandle>(filterValueSet, callback));
return(null);
}
public static void AssertFilterMulti(EPStatementSPI statementSPI, string eventTypeName, SupportFilterItem[][] expected)
{
FilterServiceSPI filterServiceSPI = (FilterServiceSPI)statementSPI.StatementContext.FilterService;
FilterSet set = filterServiceSPI.Take(Collections.SingletonSet(statementSPI.StatementId));
FilterSetEntry filterSetEntry = null;
foreach (FilterSetEntry entry in set.Filters)
{
if (entry.FilterValueSet.EventType.Name.Equals(eventTypeName))
{
if (filterSetEntry != null)
{
Assert.Fail("Multiple filters for type " + eventTypeName);
}
filterSetEntry = entry;
}
}
FilterValueSet valueSet = filterSetEntry.FilterValueSet;
FilterValueSetParam[][] @params = valueSet.Parameters;
var comparator = new Func <SupportFilterItem, SupportFilterItem, int>(
(o1, o2) => {
var o1name = o1.Name;
var o2name = o2.Name;
if (o1name == o2name)
{
if (o1.Op > o1.Op)
{
return(1);
}
if (o1.Op < o1.Op)
{
return(-1);
}
return(0);
}
return(o1name.CompareTo(o2name));
});
var found = new SupportFilterItem[@params.Length][];
for (int i = 0; i < found.Length; i++)
{
found[i] = new SupportFilterItem[@params[i].Length];
for (int j = 0; j < @params[i].Length; j++)
{
found[i][j] = new SupportFilterItem(@params[i][j].Lookupable.Expression.ToString(),
@params[i][j].FilterOperator);
}
Collections.SortInPlace(found[i], comparator);
}
for (int i = 0; i < expected.Length; i++)
{
Collections.SortInPlace(expected[i], comparator);
}
EPAssertionUtil.AssertEqualsAnyOrder(expected, found);
filterServiceSPI.Apply(set);
}
