@Override
  public Collection<SNode> tryToApply(
      TemplateExecutionEnvironment environment, TemplateContext context)
      throws GenerationException {
    if (!checkCondition(context, environment.getGenerator())) {
      return null;
    }

    environment.getTracer().pushRule(myNodePointer);
    try {
      if (environment.getGenerator().isIncremental()) {
        // turn off tracing
        NodeReadEventsCaster.setNodesReadListener(null);
      }

      return apply(context, environment.getEnvironment(context.getInput(), this));
    } catch (AbandonRuleInputException e) {
      return Collections.emptyList();
    } finally {
      if (environment.getGenerator().isIncremental()) {
        // restore tracing
        NodeReadEventsCaster.removeNodesReadListener();
      }
      environment.getTracer().closeRule(myNodePointer);
    }
  }
 @Override
 public void executeInContext(SNode outputNode, TemplateContext context, PostProcessor processor) {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     wrapped.executeInContext(outputNode, context, processor);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public SNode executeInContext(SNode outputNode, TemplateContext context, NodeMapper mapper) {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.executeInContext(outputNode, context, mapper);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public void executeScript(TemplateMappingScript mappingScript, SModel model)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     wrapped.executeScript(mappingScript, model);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public boolean evaluate(@NotNull IfMacroCondition condition, @NotNull IfMacroContext context)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.evaluate(condition, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public SNode evaluateInsertQuery(
     SNode inputNode, SNode macroNode, SNode query, @NotNull TemplateContext context) {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.evaluateInsertQuery(inputNode, macroNode, query, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public Object evaluateVariableQuery(
     SNode inputNode, SNode query, @NotNull TemplateContext context) {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.evaluateVariableQuery(inputNode, query, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public SNode getContextNode(TemplateWeavingRule rule, TemplateContext context)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.getContextNode(rule, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public boolean isApplicable(
     @NotNull TemplateRuleWithCondition rule, @NotNull TemplateContext context)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.isApplicable(rule, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Nullable
 @Override
 public Object evaluate(@NotNull PropertyValueQuery query, @NotNull PropertyMacroContext context)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.evaluate(query, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public SNode getContextNodeForTemplateFragment(
     SNode templateFragmentNode, SNode mainContextNode, @NotNull TemplateContext context) {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.getContextNodeForTemplateFragment(
         templateFragmentNode, mainContextNode, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @NotNull
 @Override
 public Collection<SNode> evaluate(
     @NotNull SourceNodesQuery query, @NotNull SourceSubstituteMacroNodesContext context)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.evaluate(query, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public boolean applyRule(
     TemplateWeavingRule rule, TemplateContext context, SNode outputContextNode)
     throws GenerationException {
   // FIXME why there's code above not to listen when interpreted rule is applied? Should I do the
   // same here?
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.applyRule(rule, context, outputContextNode);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public Collection<SNode> applyRule(TemplateRootMappingRule rule, TemplateContext context)
     throws GenerationException {
   if (rule instanceof TemplateRootMappingRuleInterpreted) {
     return wrapped.applyRule(rule, context);
   }
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.applyRule(rule, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public Object getReferentTarget(
     SNode node, SNode outputNode, SNode refMacro, TemplateContext context) {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     Object target = wrapped.getReferentTarget(node, outputNode, refMacro, context);
     if (target instanceof SNode) {
       listener.readNode((SNode) target);
     }
     return target;
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public SNode executeMapSrcNodeMacro(
     SNode inputNode,
     SNode mapSrcNodeOrListMacro,
     SNode parentOutputNode,
     @NotNull TemplateContext context)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     return wrapped.executeMapSrcNodeMacro(
         inputNode, mapSrcNodeOrListMacro, parentOutputNode, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
 @Override
 public void executeMapSrcNodeMacro_PostProc(
     SNode inputNode,
     SNode mapSrcNodeOrListMacro,
     SNode outputNode,
     @NotNull TemplateContext context)
     throws GenerationFailureException {
   try {
     NodeReadEventsCaster.setNodesReadListener(listener);
     wrapped.executeMapSrcNodeMacro_PostProc(
         inputNode, mapSrcNodeOrListMacro, outputNode, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }
Example #18
0
  public <Result> Result runCheckingAction(_FunctionTypes._return_P0_E0<? extends Result> action) {
    final Set<SNode> accessedNodes = new HashSet<SNode>();
    final Object[] result = new Object[1];
    try {
      AbstractNodesReadListener listener =
          new AbstractNodesReadListener() {
            @Override
            public void nodeUnclassifiedReadAccess(SNode node) {
              SetSequence.fromSet(accessedNodes).addElement(node);
            }

            @Override
            public void nodePropertyReadAccess(SNode node, String name, String value) {
              SetSequence.fromSet(accessedNodes).addElement(node);
            }

            @Override
            public void nodeReferentReadAccess(SNode node, String role, SNode referent) {
              SetSequence.fromSet(accessedNodes).addElement(node);
              SetSequence.fromSet(accessedNodes).addElement(referent);
            }

            @Override
            public void nodeChildReadAccess(SNode node, String role, SNode child) {
              SetSequence.fromSet(accessedNodes).addElement(node);
              SetSequence.fromSet(accessedNodes).addElement(child);
            }
          };
      NodeReadEventsCaster.setNodesReadListener(listener);
      result[0] = action.invoke();
    } finally {
      NodeReadEventsCaster.removeNodesReadListener();
    }
    for (SNode accessedNode : accessedNodes) {
      addDependency(accessedNode);
    }
    return (Result) result[0];
  }
 @Override
 public Collection<SNode> applyRule(TemplateReductionRule rule, TemplateContext context)
     throws GenerationException {
   try {
     final DependenciesReadListener l;
     if (context.getEnvironment().getGenerator().isIncremental()) {
       // this code used to be in TemplateReductionRuleInterpreted, added to address MPS-16916
       // Moved here for next reasons: (a) generated rules shall behave the same as interpreted;
       // (b) this class is the only place we install listeners via NodeReadEventsCaster, and there
       // shall be no way to get into TRRI with a
       // listener installed (for TRRI to uninstall one) other than through this method.
       // However, I don't understand why there's difference in change tracking in incremental vs
       // non-incremental mode,
       // and why only reduction rules are considered.
       l = null; // turn tracing off
     } else {
       l = listener;
     }
     NodeReadEventsCaster.setNodesReadListener(l);
     return wrapped.applyRule(rule, context);
   } finally {
     NodeReadEventsCaster.removeNodesReadListener();
   }
 }