public static IDictionary<FilterSpecActivatable, FilterValueSetParam[][]> ComputeAddendumForStatement(
ContextControllerStatementDesc statementDesc,
ContextControllerFactory[] controllerFactories,
object[] allPartitionKeys,
AgentInstanceContext agentInstanceContextCreate)
{
IDictionary<int, FilterSpecActivatable> filters =
statementDesc.Lightweight.StatementContext.FilterSpecActivatables;
IDictionary<FilterSpecActivatable, FilterValueSetParam[][]> map =
new IdentityDictionary<FilterSpecActivatable, FilterValueSetParam[][]>();
foreach (var filter in filters) {
var addendum = ComputeAddendum(
allPartitionKeys,
filter.Value,
true,
statementDesc,
controllerFactories,
agentInstanceContextCreate);
if (addendum != null && addendum.Length > 0) {
map.Put(filter.Value, addendum);
}
}
return map;
}
public void SaveEnumerationMethodLastValue(Object node, Object result)
{
var snapshot = _lastValueCacheStack.ToArray();
var entry = new ExpressionResultCacheEntry <long[], Object>(snapshot, result);
_enumMethodCache.Put(node, new compat.WeakReference <ExpressionResultCacheEntry <long[], Object> >(entry));
}
/// <summary>Find elements matching selector.</summary>
/// <param name="query">CSS selector</param>
/// <param name="roots">root elements to descend into</param>
/// <returns>matching elements, empty if none</returns>
public static Elements Select(String query, IEnumerable <iText.StyledXmlParser.Jsoup.Nodes.Element> roots)
{
Validate.NotEmpty(query);
Validate.NotNull(roots);
Evaluator evaluator = QueryParser.Parse(query);
List <iText.StyledXmlParser.Jsoup.Nodes.Element> elements = new List <iText.StyledXmlParser.Jsoup.Nodes.Element
>();
IdentityDictionary <iText.StyledXmlParser.Jsoup.Nodes.Element, bool?> seenElements = new IdentityDictionary
<iText.StyledXmlParser.Jsoup.Nodes.Element, bool?>();
// dedupe elements by identity, not equality
foreach (iText.StyledXmlParser.Jsoup.Nodes.Element root in roots)
{
Elements found = Select(evaluator, root);
foreach (iText.StyledXmlParser.Jsoup.Nodes.Element el in found)
{
if (!seenElements.ContainsKey(el))
{
elements.Add(el);
seenElements.Put(el, true);
}
}
}
return(new Elements(elements));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="rootStream">is the stream supplying the lookup event</param>
/// <param name="rootStreamName">is the name of the stream supplying the lookup event</param>
/// <param name="numStreams">is the number of streams</param>
/// <param name="lookupInstructions">is a list of lookups to perform</param>
/// <param name="requiredPerStream">indicates which streams are required and which are optional in the lookup</param>
/// <param name="assemblyInstructionFactories">factories for assembly</param>
public LookupInstructionExecNode(
int rootStream,
string rootStreamName,
int numStreams,
LookupInstructionExec[] lookupInstructions,
bool[] requiredPerStream,
BaseAssemblyNodeFactory[] assemblyInstructionFactories)
{
this._rootStream = rootStream;
this._rootStreamName = rootStreamName;
this._numStreams = numStreams;
this._lookupInstructions = lookupInstructions;
this._requiredPerStream = requiredPerStream;
// We have a list of factories that are pointing to each other in a tree, i.e.:
// F1 (=>F3), F2 (=>F3), F3
IDictionary<BaseAssemblyNodeFactory, BaseAssemblyNode> nodes =
new IdentityDictionary<BaseAssemblyNodeFactory, BaseAssemblyNode>();
foreach (var factory in assemblyInstructionFactories) {
var node = factory.MakeAssemblerUnassociated();
nodes.Put(factory, node);
}
// re-associate each node after allocation
foreach (var nodeWithFactory in nodes) {
var parentFactory = nodeWithFactory.Key.ParentNode;
if (parentFactory != null) {
var parent = nodes.Get(parentFactory);
nodeWithFactory.Value.ParentAssembler = parent;
}
foreach (var childNodeFactory in nodeWithFactory.Key.ChildNodes) {
var child = nodes.Get(childNodeFactory);
nodeWithFactory.Value.AddChild(child);
}
}
_assemblyInstructions = new BaseAssemblyNode[assemblyInstructionFactories.Length];
for (var i = 0; i < assemblyInstructionFactories.Length; i++) {
_assemblyInstructions[i] = nodes.Get(assemblyInstructionFactories[i]);
}
_myResultAssembler = new MyResultAssembler(rootStream);
_assemblyInstructions[_assemblyInstructions.Length - 1].ParentAssembler = _myResultAssembler;
// Determine up to which instruction we are dealing with optional results.
// When dealing with optional results we don't do fast exists if we find no lookup results
_requireResultsInstruction = 1; // we always require results from the very first lookup
for (var i = 1; i < lookupInstructions.Length; i++) {
var fromStream = lookupInstructions[i].FromStream;
if (requiredPerStream[fromStream]) {
_requireResultsInstruction =
i + 1; // require results as long as the from-stream is a required stream
}
else {
break;
}
}
}
public void SaveDeclaredExpressionLastColl(Object node, EventBean[] eventsPerStream, ICollection <EventBean> result)
{
var copy = new EventBean[eventsPerStream.Length];
Array.Copy(eventsPerStream, 0, copy, 0, copy.Length);
var entry = new ExpressionResultCacheEntry <EventBean[], ICollection <EventBean> >(copy, result);
_exprDeclCacheCollection.Put(node, new compat.WeakReference <ExpressionResultCacheEntry <EventBean[], ICollection <EventBean> > >(entry));
}
