(*should_revisit)[e->dst()->id()] = true;
        }
      }
    }
  }

  void SetPredicate(Node* n, absl::Span<const int> output_idxs, Predicate* pred,
                    std::vector<bool>* should_revisit) {
    for (int output_idx : output_idxs) {
      SetPredicate(n, output_idx, pred, should_revisit);
    }
  }

  Status HandleSwitch(Node* n, std::vector<bool>* should_revisit);

        }
    }

    private void addRule(RuleBinder rule, NodeAtStateIndex index, ModelBinding binding) {
        Reference reference = new Reference(rule, index, binding);
        BindingPredicate predicate = binding.getPredicate();
        if (predicate.getPath() != null) {
            if (predicate.getScope() != null) {
                throw new UnsupportedOperationException("Currently not implemented");
            }

            ModelBinding subjectBinding = binder.getSubjectBinding();
            // Only report subject binding if target state is after node creation
            if (subjectBinding.getPredicate().getState().compareTo(ModelNode.State.Created) > 0) {
                UnboundRuleInput.Builder inputBuilder = toInputBuilder(subjectBinding);
                builder.mutableInput(inputBuilder);
            }

            @Override
            public void execute(ModelBinding modelBinding) {
                ModelNodeInternal node = modelBinding.getNode();
                BindingPredicate predicate = modelBinding.getPredicate();
                if (node.isAtLeast(predicate.getState())) {
                    throw new IllegalStateException(String.format("Cannot add rule %s for model element '%s' at state %s as this element is already at state %s.",

     * the target state, not the input state. Implicitly, a rule accepts as input the subject in the state that is the predecessor of the target state.
     */
    public BindingPredicate getPredicate() {
        return predicate;
    }

    public boolean isBound() {
        return boundTo != null;
    }

    public ModelNodeInternal getNode() {
        if (boundTo == null) {

        int i = 0;
        for (ModelBinding binding : bindings) {
            ModelNodeInternal element = binding.getNode();
            ModelView<?> view = element.asImmutable(binding.getPredicate().getType(), descriptor);
            array[i++] = view;
        }
        @SuppressWarnings("unchecked") List<ModelView<?>> views = Arrays.asList(array);
        return views;
    }

    @Override

  // else print the shorter single type.
  p << " : ";
  if (getTrueOutput().getType() != data_operand_ty ||
      getFalseOutput().getType() != data_operand_ty ||
      mlir::isa<UnrankedTensorType>(getPredicate().getType())) {
    p.printFunctionalType(getOperation());
  } else {
    p << getType(0);
  }
  p.printOptionalAttrDict(getOperation()->getAttrs());
}

  // TakeWhileDataset op. The TakeWhileDataset op always has N+1 inputs.
  // TODO(jpienaar): Avoid this lookup.
  auto module = op->getParentOfType<ModuleOp>();
  auto f = module.lookupSymbol<func::FuncOp>(op.getPredicate());
  // Skip if function is not found or more than one caller.
  if (!f || !llvm::hasSingleElement(GetCallers(f))) return false;
  return InferShapeForDatasetOpCommon(op, f, max_iterations);
}