/**
   * @param wireNew If true, OutputPorts of operators will be added to readyOutputs once they are
   *     wired.
   */
  private void autoWire(
      CompatibilityLevel level,
      List<Operator> operators,
      LinkedList<OutputPort> readyOutputs,
      boolean recursive,
      boolean wireNew)
      throws PortException {
    transformMDNeighbourhood();

    for (Operator op : operators) {
      try {
        readyOutputs = op.preAutoWire(readyOutputs);
      } catch (OperatorException e) {
        getEnclosingOperator().getLogger().log(Level.WARNING, "During auto-wiring: " + e, e);
      }
      autoWire(level, op.getInputPorts(), readyOutputs);
      transformMDNeighbourhood();
      if (recursive) {
        if (op instanceof OperatorChain) {
          for (ExecutionUnit subprocess : ((OperatorChain) op).getSubprocesses()) {
            // we have already removed all connections, so keepConnections=true in recursive call
            subprocess.autoWire(level, true, recursive);
          }
        }
      }
      if (wireNew) {
        addReadyOutputs(readyOutputs, op.getOutputPorts());
      }
    }
    autoWire(level, getInnerSinks(), readyOutputs);
    transformMDNeighbourhood();
  }
  /**
   * Moves the operators from this process to another process, keeping all connections intact. TODO:
   * Test more rigorously. Do we register/unregister everything correctly?
   *
   * @return the number of ports the connections of which could not be restored
   */
  public int stealOperatorsFrom(ExecutionUnit otherUnit) {
    int failedReconnects = 0;

    // remember source and sink connections so we can reconnect them later.
    Map<String, InputPort> sourceMap = new HashMap<String, InputPort>();
    Map<String, OutputPort> sinkMap = new HashMap<String, OutputPort>();
    for (OutputPort source : otherUnit.getInnerSources().getAllPorts()) {
      if (source.isConnected()) {
        sourceMap.put(source.getName(), source.getDestination());
      }
    }
    otherUnit.getInnerSources().disconnectAll();
    for (InputPort sink : otherUnit.getInnerSinks().getAllPorts()) {
      if (sink.isConnected()) {
        sinkMap.put(sink.getName(), sink.getSource());
      }
    }
    otherUnit.getInnerSinks().disconnectAll();

    // Move operators
    Iterator<Operator> i = otherUnit.operators.iterator();
    while (i.hasNext()) {
      Operator operator = i.next();
      i.remove();
      otherUnit.unregister(operator);
      Process otherProcess = operator.getProcess();
      if (otherProcess != null) {
        operator.unregisterOperator(otherProcess);
      }
      this.operators.add(operator);
      operator.setEnclosingProcess(null);
      // operator.unregisterOperator(operator.getProcess());
      registerOperator(operator, true);
      // operator.registerOperator(this.getEnclosingOperator().getProcess());
    }

    // Rewire sources and sinks
    for (Map.Entry<String, InputPort> entry : sourceMap.entrySet()) {
      OutputPort mySource = getInnerSources().getPortByName(entry.getKey());
      if (mySource != null) {
        mySource.connectTo(entry.getValue());
      } else {
        failedReconnects++;
      }
    }
    getInnerSources().unlockPortExtenders();

    for (Map.Entry<String, OutputPort> entry : sinkMap.entrySet()) {
      InputPort mySink = getInnerSinks().getPortByName(entry.getKey());
      if (mySink != null) {
        entry.getValue().connectTo(mySink);
      } else {
        failedReconnects++;
      }
    }
    getInnerSinks().unlockPortExtenders();

    fireUpdate(this);
    return failedReconnects;
  }
  /**
   * Clones operators contained in <code>original</code>, adds them to this execution unit and wires
   * them as they were originally.
   *
   * @param forParallelExecution Indicates whether this clone is supposed to be executed in
   *     parallel. If yes, the clone will not be registered with the parent process and will share
   *     its {@link Operator#applyCount} with the original.
   */
  public void cloneExecutionUnitFrom(ExecutionUnit original, boolean forParallelExecution) {
    // Clone operators
    Map<String, Operator> clonedOperatorsByName = new HashMap<String, Operator>();
    for (Operator originalChild : original.operators) {
      Operator clonedOperator =
          originalChild.cloneOperator(originalChild.getName(), forParallelExecution);
      addOperator(clonedOperator, !forParallelExecution);
      clonedOperatorsByName.put(originalChild.getName(), clonedOperator);
    }

    // Restore connections
    cloneConnections(original.getInnerSources(), original, clonedOperatorsByName);
    for (Operator op : original.operators) {
      cloneConnections(op.getOutputPorts(), original, clonedOperatorsByName);
    }

    // Unlock
    original.getInnerSources().unlockPortExtenders();
    original.getInnerSinks().unlockPortExtenders();
    for (Operator op : this.operators) {
      op.getInputPorts().unlockPortExtenders();
      op.getOutputPorts().unlockPortExtenders();
    }

    // Other:
    this.expanded = original.expanded;
  }
  @Override
  protected String conditionedApply(
      Operator operator, String operatorTypeName, XMLImporter importer) {
    if (operator.getParameters().isSpecified(parameterName)) {
      try {
        String attributeName = operator.getParameterAsString(parameterName);

        ChangeAttributeRole setRoleOp = OperatorService.createOperator(ChangeAttributeRole.class);

        // inserting operator into process
        ExecutionUnit process = operator.getExecutionUnit();
        int operatorIndex = process.getOperators().indexOf(operator);
        process.addOperator(setRoleOp, operatorIndex + 1);

        // setting parameter
        setRoleOp.setParameter(ChangeAttributeRole.PARAMETER_NAME, attributeName);
        setRoleOp.setParameter(ChangeAttributeRole.PARAMETER_TARGET_ROLE, targetRole);
        return "Inserted operator for explicitly setting attribute <code>"
            + attributeName
            + "</code> to role <code>"
            + targetRole
            + "</code>";
      } catch (UndefinedParameterError e) {
        return null;
      } catch (OperatorCreationException e) {
        return null;
      }
    }
    return null;
  }
 private void unwire(Operator op, boolean recursive) throws PortException {
   op.getOutputPorts().disconnectAll();
   if (recursive) {
     if (op instanceof OperatorChain) {
       for (ExecutionUnit subprocess : ((OperatorChain) op).getSubprocesses()) {
         subprocess.unwire(recursive);
       }
     }
   }
 }
 @Override
 public void execute(ExecutionUnit unit) throws OperatorException {
   Logger logger = unit.getEnclosingOperator().getLogger();
   if (logger.isLoggable(Level.FINE)) {
     logger.fine(
         "Executing subprocess "
             + unit.getEnclosingOperator().getName()
             + "."
             + unit.getName()
             + ". Execution order is: "
             + unit.getOperators());
   }
   Enumeration<Operator> opEnum = unit.getOperatorEnumeration();
   while (opEnum.hasMoreElements()) {
     // for (Operator operator : unit.getOperators()) {
     Operator operator = opEnum.nextElement();
     operator.execute();
     operator.freeMemory();
   }
 }
Esempio n. 7
0
  /**
   * The given operators will be inserted at the last position of the currently selected operator
   * chain.
   */
  public void insert(List<Operator> newOperators) {
    Object selectedNode = getSelectedOperator();
    if (selectedNode == null) {
      SwingTools.showVerySimpleErrorMessage("cannot_insert_operator");
      return;
    } else if (mainFrame.getProcessPanel().getProcessRenderer().getModel().getDisplayedChain()
        == selectedNode) {
      for (Operator newOperator : newOperators) {
        int index =
            mainFrame
                .getProcessPanel()
                .getProcessRenderer()
                .getProcessIndexUnder(
                    mainFrame
                        .getProcessPanel()
                        .getProcessRenderer()
                        .getModel()
                        .getCurrentMousePosition());
        if (index == -1) {
          index = 0;
        }
        ((OperatorChain) selectedNode).getSubprocess(index).addOperator(newOperator);
      }
    } else {
      int i = 0;
      Operator selectedOperator = (Operator) selectedNode;
      ExecutionUnit process = selectedOperator.getExecutionUnit();
      int parentIndex = process.getOperators().indexOf(selectedOperator) + 1;
      for (Operator newOperator : newOperators) {
        process.addOperator(newOperator, parentIndex + i);
        i++;
      }
    }

    AutoWireThread.autoWireInBackground(newOperators, true);
    mainFrame.selectOperators(newOperators);
  }
        /** Draws the operator annoations. */
        private void draw(
            final ExecutionUnit process,
            final Graphics2D g2,
            final ProcessRendererModel rendererModel,
            final boolean printing) {
          if (!visualizer.isActive()) {
            return;
          }

          // operator attached annotations
          List<Operator> selectedOperators = rendererModel.getSelectedOperators();
          for (Operator operator : process.getOperators()) {
            if (selectedOperators.contains(operator)) {
              continue;
            }
            drawOpAnno(operator, g2, rendererModel, printing);
          }
          // selected operators annotations need to be drawn over non selected ones
          for (Operator selOp : selectedOperators) {
            if (process.equals(selOp.getExecutionUnit())) {
              drawOpAnno(selOp, g2, rendererModel, printing);
            }
          }
        }
  @Override
  public void apply() {
    try {
      Operator oldOperator = inputPort.getPorts().getOwner().getOperator();
      Operator newOperator =
          NewOperatorDialog.selectMatchingOperator(
              RapidMinerGUI.getMainFrame().getActions(), null, neededClass, null, null);

      if (newOperator != null) {
        ExecutionUnit unit = inputPort.getPorts().getOwner().getConnectionContext();
        int index = unit.getIndexOfOperator(oldOperator);
        if (index == -1) {
          unit.addOperator(newOperator);
        } else {
          unit.addOperator(newOperator, unit.getIndexOfOperator(oldOperator));
        }
        if (RapidMinerGUI.getMainFrame().VALIDATE_AUTOMATICALLY_ACTION.isSelected()) {
          unit.autoWireSingle(newOperator, CompatibilityLevel.VERSION_5, true, true);
        }
      }
    } catch (OperatorCreationException e) {
    }
  }
  private void cloneConnections(
      OutputPorts originalPorts,
      ExecutionUnit originalExecutionUnit,
      Map<String, Operator> clonedOperatorsByName) {
    for (OutputPort originalSource : originalPorts.getAllPorts()) {
      if (originalSource.isConnected()) {

        OutputPort mySource;
        if (originalPorts.getOwner().getOperator()
            == originalExecutionUnit.getEnclosingOperator()) {
          // this is an inner source
          mySource = getInnerSources().getPortByName(originalSource.getName());
          if (mySource == null) {
            throw new RuntimeException(
                "Error during clone: Corresponding source for "
                    + originalSource
                    + " not found (no such inner source).");
          }
        } else {
          // this is an output port
          Operator myOperator =
              clonedOperatorsByName.get(
                  originalSource.getPorts().getOwner().getOperator().getName());
          if (myOperator == null) {
            throw new RuntimeException(
                "Error during clone: Corresponding source for "
                    + originalSource
                    + " not found (no such operator).");
          }
          mySource = myOperator.getOutputPorts().getPortByName(originalSource.getName());
          if (mySource == null) {
            throw new RuntimeException(
                "Error during clone: Corresponding source for "
                    + originalSource
                    + " not found (no such output port).");
          }
        }

        InputPort originalDestination = originalSource.getDestination();
        InputPort myDestination;
        if (originalDestination.getPorts().getOwner().getOperator()
            == originalExecutionUnit.getEnclosingOperator()) {
          // this is an inner sink
          myDestination = getInnerSinks().getPortByName(originalDestination.getName());
          if (myDestination == null) {
            throw new RuntimeException(
                "Error during clone: Corresponding destination for "
                    + originalDestination
                    + " not found (no such inner sink).");
          }
        } else {
          // this is an input port
          Operator myOperator =
              clonedOperatorsByName.get(
                  originalDestination.getPorts().getOwner().getOperator().getName());
          if (myOperator == null) {
            throw new RuntimeException(
                "Error during clone: Corresponding destination for "
                    + originalDestination
                    + " not found (no such operator).");
          }
          myDestination = myOperator.getInputPorts().getPortByName(originalDestination.getName());
          if (myDestination == null) {
            throw new RuntimeException(
                "Error during clone: Corresponding destination for "
                    + originalDestination
                    + " not found (no such input port).");
          }
        }
        mySource.connectTo(myDestination);
      }
    }
  }