private LeftTupleSource unwrapLeftInput(LeftTupleSource leftInput) {
if (leftInput.getType() == NodeTypeEnums.FromNode
|| leftInput.getType() == NodeTypeEnums.ReactiveFromNode) {
return leftInput.getLeftTupleSource();
}
return leftInput;
}
protected void initInferredMask(LeftTupleSource leftInput) {
LeftTupleSource unwrappedLeft = unwrapLeftInput(leftInput);
if (unwrappedLeft.getType() == NodeTypeEnums.LeftInputAdapterNode
&& ((LeftInputAdapterNode) unwrappedLeft).getParentObjectSource().getType()
== NodeTypeEnums.AlphaNode) {
AlphaNode alphaNode =
(AlphaNode) ((LeftInputAdapterNode) unwrappedLeft).getParentObjectSource();
leftInferredMask = alphaNode.updateMask(leftDeclaredMask);
} else {
leftInferredMask = leftDeclaredMask;
}
leftInferredMask = leftInferredMask.resetAll(leftNegativeMask);
}
protected void initDeclaredMask(BuildContext context, LeftTupleSource leftInput) {
if (context == null || context.getLastBuiltPatterns() == null) {
// only happens during unit tests
leftDeclaredMask = AllSetBitMask.get();
return;
}
if (leftInput.getType() != NodeTypeEnums.LeftInputAdapterNode) {
// BetaNode's not after LIANode are not relevant for left mask property specific, so don't
// block anything.
leftDeclaredMask = AllSetBitMask.get();
return;
}
Pattern pattern = context.getLastBuiltPatterns()[1]; // left input pattern
ObjectType objectType =
pattern == null || this.getType() == NodeTypeEnums.AccumulateNode
? ((LeftInputAdapterNode) leftInput)
.getParentObjectSource()
.getObjectTypeNode()
.getObjectType()
: pattern.getObjectType();
if (!(objectType instanceof ClassObjectType)) {
// Only ClassObjectType can use property specific
leftDeclaredMask = AllSetBitMask.get();
return;
}
Class objectClass = ((ClassWireable) objectType).getClassType();
if (isPropertyReactive(context, objectClass)) {
// TODO: at the moment if pattern is null (e.g. for eval node) we cannot calculate the mask,
// so we leave it to 0
if (pattern != null) {
List<String> leftListenedProperties = pattern.getListenedProperties();
List<String> settableProperties =
getSettableProperties(context.getKnowledgeBase(), objectClass);
leftDeclaredMask = calculatePositiveMask(leftListenedProperties, settableProperties);
leftNegativeMask = calculateNegativeMask(leftListenedProperties, settableProperties);
setLeftListenedProperties(leftListenedProperties);
}
} else {
// if property specific is not on, then accept all modification propagations
leftDeclaredMask = AllSetBitMask.get();
}
}
public static int getOffset(NetworkNode node) {
LeftTupleSource lt;
int offset = 1;
if (NodeTypeEnums.isTerminalNode(node)) {
lt = ((TerminalNode) node).getLeftTupleSource();
offset++;
} else if (node.getType() == NodeTypeEnums.RightInputAdaterNode) {
lt = ((RightInputAdapterNode) node).getLeftTupleSource();
} else {
lt = (LeftTupleSource) node;
}
while (lt.getType() != NodeTypeEnums.LeftInputAdapterNode) {
offset++;
lt = lt.getLeftTupleSource();
}
return offset;
}
private BaseNode[] evalQuery(
String queryName,
DroolsQuery queryObject,
InternalFactHandle handle,
PropagationContext pCtx) {
BaseNode[] tnodes = (BaseNode[]) ruleBase.getReteooBuilder().getTerminalNodes(queryName);
if (this.ruleBase.getConfiguration().isPhreakEnabled()) {
if (tnodes == null) {
throw new RuntimeException("Query '" + queryName + "' does not exist");
}
QueryTerminalNode tnode = (QueryTerminalNode) tnodes[0];
LeftTupleSource lts = tnode.getLeftTupleSource();
while (lts.getType() != NodeTypeEnums.LeftInputAdapterNode) {
lts = lts.getLeftTupleSource();
}
LeftInputAdapterNode lian = (LeftInputAdapterNode) lts;
LiaNodeMemory lmem = (LiaNodeMemory) getNodeMemory((MemoryFactory) lts);
SegmentMemory lsmem = lmem.getSegmentMemory();
if (lsmem == null) {
lsmem = SegmentUtilities.createSegmentMemory(lts, this);
}
LeftInputAdapterNode.doInsertObject(
handle, pCtx, lian, this, lmem, false, queryObject.isOpen());
List<PathMemory> rmems = lmem.getSegmentMemory().getPathMemories();
for (int i = 0, length = rmems.size(); i < length; i++) {
PathMemory rm = rmems.get(i);
RuleNetworkEvaluatorActivation evaluator =
agenda.createRuleNetworkEvaluatorActivation(
Integer.MAX_VALUE, rm, (TerminalNode) rm.getNetworkNode());
evaluator.evaluateNetwork(this, 0, -1);
}
} else {
// no need to call retract, as no leftmemory used.
getEntryPointNode().assertQuery(handle, pCtx, this);
pCtx.evaluateActionQueue(this);
}
return tnodes;
}
