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