/// <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 ExpressionResultCacheEntry <EventBean[], Object> GetDeclaredExpressionLastValue(Object node, EventBean[] eventsPerStream)
{
InitExprDeclaredCacheObject();
var cacheRef = _exprDeclCacheObject.Get(node);
if (cacheRef == null)
{
return(null);
}
var entry = cacheRef.Target;
if (entry == null)
{
return(null);
}
var cacheEvents = entry.Reference;
if (cacheEvents.Length != eventsPerStream.Length)
{
return(null);
}
for (int i = 0; i < cacheEvents.Length; i++)
{
if (cacheEvents[i] != eventsPerStream[i])
{
return(null);
}
}
return(entry);
}
public ExpressionResultCacheEntry <long[], Object> GetEnumerationMethodLastValue(Object node)
{
InitEnumMethodCache();
var cacheRef = _enumMethodCache.Get(node);
if (cacheRef == null)
{
return(null);
}
ExpressionResultCacheEntry <long[], Object> entry = cacheRef.Target;
if (entry == null)
{
return(null);
}
long[] required = entry.Reference;
if (required.Length != _lastValueCacheStack.Count)
{
return(null);
}
IEnumerator <long> prov = _lastValueCacheStack.GetEnumerator();
for (int i = 0; i < _lastValueCacheStack.Count; i++)
{
prov.MoveNext();
if (!required[i].Equals(prov.Current))
{
return(null);
}
}
return(entry);
}
public FilterValueSetParam[][] GetFilterAddendum(FilterSpecCompiled filterSpecCompiled)
{
return(_filterAddendum.Get(filterSpecCompiled));
}
public FilterValueSetParam[][] GetAddendumFilters(FilterSpecCompiled filterSpec)
{
return(_addendumMap.Get(filterSpec));
}
