public String getReturnTypeName() {
      if ("stop".equals(node.getType())) {
        return null;
      }
      if (node.isFlowPart()) {
        return getCachedClassName(
            getFactoryName() + "." + StringUtil.getSimpleName(getClassName()));
      }

      String type = getMethodName();
      String className = getCachedClassName(getFactoryName() + "." + StringUtil.toFirstUpper(type));

      String nodeType = node.getType();
      if ("restructure".equals(nodeType)
          || "extend".equals(nodeType)
          || "project".equals(nodeType)
          || "checkpoint".equals(nodeType)) {
        OpePort port = node.getOutputPort();
        String modelClass = getCachedClassName(getModelClassName(port));
        return className + "<" + modelClass + ">";
      }
      if ("empty".equals(nodeType) || "confluent".equals(nodeType)) {
        String modelClass = findModelClass(node);
        modelClass = getCachedClassName(modelClass);
        return className + "<" + modelClass + ">";
      }

      return className;
    }
 public String getMethodName() {
   if (node.isCoreOperator()) {
     return node.getType();
   }
   if (node.isFlowPart()) {
     return "create";
   }
   return node.getMethodName();
 }
 @Override
 public String createVariableName() {
   String name;
   if (node.isFlowPart()) {
     name = StringUtil.getSimpleName(getFactoryName());
     name = StringUtil.removeEnds(name, "Factory");
   } else {
     name = node.getMethodName();
   }
   return StringUtil.toFirstLower(name);
 }
  private void appendDescribe(StringBuilder sb) {
    sb.append("\t@Override\n");
    sb.append("\tpublic void describe() {\n");

    Map<Integer, GenNode> map = new HashMap<Integer, GenNode>();
    for (JobPort port : frame.getInputPorts()) {
      GenImporter gen = new GenImporter(port);
      map.put(port.getId(), gen);
      nodeMap.put(port, gen);
    }

    List<GenOperator> opeList = new ArrayList<GenOperator>();
    for (NodeElement node : diagram.getContents()) {
      if (node instanceof OperatorNode) {
        OperatorNode operator = (OperatorNode) node;
        GenOperator gop = new GenOperator(operator);
        opeList.add(gop);
        getFactoryVariableName(gop.getFactoryName(), gop.isFlowPart());
        nodeMap.put(node, gop);
        for (OpePort port : operator.getPorts()) {
          nodeMap.put(port, new GenPort(port));
        }
      }
    }

    appendDescribeVariable(sb);

    for (int i = 0; ; ) {
      if (opeList.isEmpty()) {
        break;
      }
      if (i >= opeList.size()) {
        i = 0;
      }
      GenOperator node = opeList.get(i);
      if (node.complete(map)) {
        appendNode(sb, node, map);
        map.put(node.getId(), node);
        opeList.remove(node);
      } else {
        i++;
      }
    }

    sb.append("\n");
    for (JobPort port : frame.getOutputPorts()) {
      appendExporter(sb, port);
    }

    sb.append("\t}\n");
  }
 @Override
 public String getUseVariableName() {
   if (node.getOutputPorts().isEmpty()) { // empty, confluent
     return super.getUseVariableName() + ".out";
   }
   return super.getUseVariableName();
 }
 public String getClassName() {
   String name = node.getClassName();
   if (StringUtil.isEmpty(name)) {
     return "undefined_className_" + getId();
   } else {
     return name;
   }
 }
    public void appendArgsTo(StringBuilder sb) {
      List<String> args = new ArrayList<String>();
      for (OpePort port : node.getInputPorts()) {
        NodeElement cnode = port.getConnectedNode();
        GenNode gen = nodeMap.get(cnode);
        String varName = (gen != null) ? gen.getUseVariableName() : "null";
        args.add(varName);
      }
      for (Connection c : node.getIncomings()) {
        NodeElement cnode = c.getOpposite(node);
        GenNode gen = nodeMap.get(cnode);
        String varName = (gen != null) ? gen.getUseVariableName() : "null";
        args.add(varName);
      }
      for (OpeParameter param : node.getParameterList()) {
        args.add(getQualifiedValue(param.getClassName(), param.getValue()));
      }
      String nodeType = node.getType();
      if ("restructure".equals(nodeType)
          || "extend".equals(nodeType)
          || "project".equals(nodeType)) {
        OpePort port = node.getOutputPort();
        String modelClass = getModelClassName(port);
        args.add(getQualifiedValue("java.lang.Class", modelClass));
      } else if ("empty".equals(nodeType)) {
        String modelClass = findModelClass(node);
        args.add(getQualifiedValue("java.lang.Class", modelClass));
      }

      if ("confluent".equals(nodeType)) {
        switch (args.size()) {
          case 2:
          case 3:
          case 4:
            break;
          default:
            sb.append(getCachedClassName("java.util.Arrays"));
            sb.append(".asList(");
            StringUtil.mkString(sb, args);
            sb.append(")");
            return;
        }
      }
      StringUtil.mkString(sb, args);
    }
  /**
   * データモデルの種類を推測する.
   *
   * @return データモデルの種類
   */
  public GuessDataModelType guessDataModelType() {
    List<GuessDataModelType> guess = null;
    if (modelNode instanceof OpePort) {
      OpePort port = (OpePort) modelNode;
      NodeElement parent = port.getParent();
      if (parent instanceof OperatorNode) {
        OperatorNode operator = (OperatorNode) parent;
        GuessDataModelType type = operator.guessDataModelType(port);
        if (type != null) {
          if (type.isDecision()) {
            return type;
          }
          guess = new ArrayList<GuessDataModelType>();
          guess.add(type);
        }
      }
    }

    for (SiblingDataModelTreeElement c : children) {
      GuessDataModelType type = c.guessDataModelType();
      if (type != null) {
        if (type.isDecision()) {
          return type;
        }
        if (guess == null) {
          guess = new ArrayList<GuessDataModelType>();
        }
        guess.add(type);
      }
    }

    if (guess != null) {
      Collections.sort(
          guess,
          new Comparator<GuessDataModelType>() {
            @Override
            public int compare(GuessDataModelType o1, GuessDataModelType o2) {
              return o2.getGuessLevel() - o1.getGuessLevel();
            }
          });
      return guess.get(0);
    }

    return null;
  }
 public GenOperator(OperatorNode node) {
   super(node);
   this.node = node;
   for (OpePort port : node.getInputPorts()) {
     NodeElement cnode = port.getConnectedNode();
     if (cnode != null) {
       incomings.add(cnode);
     }
   }
 }
 public Object getDescription() {
   return node.getDescription();
 }
 public String getFactoryName() {
   if (node.isCoreOperator()) {
     return CORE_OP_FACTORY;
   }
   return getClassName() + "Factory";
 }
 public boolean isFlowPart() {
   return node.isFlowPart();
 }
 public Integer getId() {
   return node.getId();
 }