コード例 #1
0
  @Override
  public void execute() {
    oldType = (String) paramEncoding.getValue();

    String tempValue = newRealValue;
    tempValue = tempValue.replaceAll("'", ""); // $NON-NLS-1$ //$NON-NLS-2$
    tempValue = tempValue.replaceAll("\"", ""); // $NON-NLS-1$ //$NON-NLS-2$

    boolean newIsCustomAndoldIsNotCustom =
        tempValue.equals(EmfComponent.ENCODING_TYPE_CUSTOM)
            && !paramEncoding.getValue().equals(EmfComponent.ENCODING_TYPE_CUSTOM);
    boolean newIsNotCustomAndoldIsCustom =
        !tempValue.equals(EmfComponent.ENCODING_TYPE_CUSTOM)
            && paramEncoding.getValue().equals(EmfComponent.ENCODING_TYPE_CUSTOM);
    boolean toRefresh = false;
    if (fromCombo && (newIsCustomAndoldIsNotCustom || newIsNotCustomAndoldIsCustom)) {
      toRefresh = true;
    }
    if (ArrayUtils.contains(paramEncoding.getListItemsValue(), tempValue)) {
      paramEncoding.setValue(tempValue);
    }
    if (toRefresh) {
      getElement().setPropertyValue(EParameterName.UPDATE_COMPONENTS.getName(), Boolean.TRUE);
      if (DynamicTabbedPropertySection.getLastPropertyUsed() != null) {
        DynamicTabbedPropertySection.getLastPropertyUsed().refresh();
      }
    }
    super.execute();
  }
コード例 #2
0
  public static void updateModuleList(Node node) {
    List<ModuleNeeded> moduleNeededList = ModulesNeededProvider.getModulesNeeded();
    Set<String> moduleNameList = new TreeSet<String>();
    Set<String> moduleValueList = new TreeSet<String>();
    for (ModuleNeeded module : moduleNeededList) {

      String moduleName = module.getModuleName();
      moduleNameList.add(moduleName);
      moduleValueList.add(TalendTextUtils.addQuotes(moduleName));
    }
    Comparator<String> comprarator = new IgnoreCaseComparator();
    String[] moduleNameArray = moduleNameList.toArray(new String[0]);
    String[] moduleValueArray = moduleValueList.toArray(new String[0]);
    Arrays.sort(moduleNameArray, comprarator);
    Arrays.sort(moduleValueArray, comprarator);

    for (int i = 0; i < node.getElementParameters().size(); i++) {
      IElementParameter param = node.getElementParameters().get(i);
      if (param.getFieldType() == EParameterFieldType.MODULE_LIST) {
        param.setListItemsDisplayName(moduleNameArray);
        param.setListItemsValue(moduleValueArray);
      } else if (param.getFieldType() == EParameterFieldType.TABLE) {
        Object[] listItemsValue = param.getListItemsValue();
        if (listItemsValue != null) {
          for (Object o : listItemsValue) {
            if (o instanceof IElementParameter
                && ((IElementParameter) o).getFieldType() == EParameterFieldType.MODULE_LIST) {
              ((IElementParameter) o).setListItemsDisplayName(moduleNameArray);
              ((IElementParameter) o).setListItemsValue(moduleValueArray);
            }
          }
        }
      }
    }
  }
コード例 #3
0
  public Command createCommand(SelectionEvent selectionEvent) {
    Set<String> elementsName;
    Control ctrl;
    elementsName = hashCurControls.keySet();
    for (String name : elementsName) {
      Object o = hashCurControls.get(name);
      if (o instanceof Control) {
        ctrl = (Control) o;
        if (ctrl == null) {
          hashCurControls.remove(name);
          return null;
        }

        if (ctrl.equals(selectionEvent.getSource()) && ctrl instanceof CCombo) {
          boolean isDisposed = ((CCombo) ctrl).isDisposed();
          if (!isDisposed && (!elem.getPropertyValue(name).equals(((CCombo) ctrl).getText()))) {

            String value = new String(""); // $NON-NLS-1$
            for (int i = 0; i < elem.getElementParameters().size(); i++) {
              IElementParameter param = elem.getElementParameters().get(i);
              if (param.getName().equals(name)) {
                for (int j = 0; j < param.getListItemsValue().length; j++) {
                  if (((CCombo) ctrl).getText().equals(param.getListItemsDisplayName()[j])) {
                    value = (String) param.getListItemsValue()[j];
                  }
                }
              }
            }
            if (value.equals(elem.getPropertyValue(name))) { // same
              // value so
              // no
              // need to do
              // anything
              return null;
            }
            CorePlugin.getDefault().getLibrariesService().resetModulesNeeded();
            return new PropertyChangeCommand(elem, name, value);
          }
        }
      }
    }
    return null;
  }
  public static ElementParameterType getElemeterParameterType(IElementParameter param) {
    if (param == null) {
      return null;
    }
    ElementParameterType targetPramType = TalendFileFactory.eINSTANCE.createElementParameterType();
    if (param.getParentParameter() != null) {
      targetPramType.setName(
          param.getParentParameter().getName() + ":" + param.getName()); // $NON-NLS-1$
    } else {
      targetPramType.setName(param.getName());
    }
    targetPramType.setField(param.getFieldType().getName());
    targetPramType.setContextMode(param.isContextMode());
    Object value = param.getValue();
    if (param.getFieldType().equals(EParameterFieldType.TABLE) && value != null) {
      List<Map<String, Object>> tableValues = (List<Map<String, Object>>) value;
      for (Map<String, Object> currentLine : tableValues) {
        for (int i = 0; i < param.getListItemsDisplayCodeName().length; i++) {
          ElementValueType elementValue = TalendFileFactory.eINSTANCE.createElementValueType();
          elementValue.setElementRef(param.getListItemsDisplayCodeName()[i]);
          Object o = currentLine.get(param.getListItemsDisplayCodeName()[i]);

          IElementParameter tmpParam = null;
          Object[] listItemsValue = param.getListItemsValue();
          if (listItemsValue.length > i) {
            tmpParam = (IElementParameter) listItemsValue[i];
          }
          String strValue = ""; // $NON-NLS-1$
          if (o instanceof Integer && tmpParam != null) {
            if (tmpParam.getListItemsValue().length == 0) {
              strValue = ""; // $NON-NLS-1$
            } else {
              strValue = (String) tmpParam.getListItemsValue()[(Integer) o];
            }
          } else {
            if (o instanceof String) {
              strValue = (String) o;
            } else {
              if (o instanceof Boolean) {
                strValue = ((Boolean) o).toString();
              }
            }
          }
          if (tmpParam != null && tmpParam.getFieldType().equals(EParameterFieldType.PASSWORD)) {
            elementValue.setValue(strValue, true);
          } else {
            elementValue.setValue(strValue);
          }
          //
          Object object =
              currentLine.get(param.getListItemsDisplayCodeName()[i] + IEbcdicConstant.REF_TYPE);
          if (object != null) {
            elementValue.setType((String) object);
          }
          targetPramType.getElementValue().add(elementValue);
        }
      }
    } else {
      if (value == null) {
        targetPramType.setValue(""); // $NON-NLS-1$
      } else {
        if (value instanceof Boolean) {
          targetPramType.setValue(((Boolean) value).toString());
        } else {
          if (value instanceof String) {
            targetPramType.setRawValue(value.toString());
          }
        }
      }
    }

    return targetPramType;
  }
  /**
   * load the Element's parameters to EMF Model
   *
   * @param elemParam
   * @param paType
   */
  public static void loadElementParameters(
      Element elemParam, ParametersType paType, String repParamName) {
    if (paType == null || elemParam == null) {
      return;
    }
    EList listParamType = paType.getElementParameter();
    ElementParameterType repositoryParam = null;
    if (repParamName != null && !repParamName.equals("")) {
      repositoryParam = findElementParameterType(paType, repParamName);
    } else {
      repositoryParam =
          findElementParameterType(
              paType,
              EParameterName.PROPERTY_TYPE.getName()
                  + ":"
                  + EParameterName.PROPERTY_TYPE.getName());
    }

    IElementParameter statsDBType = null;
    IElementParameter implicitDBType = null;
    IElementParameter statsDBVersion = null;
    IElementParameter implicitDBVersion = null;

    for (int j = 0; j < listParamType.size(); j++) {
      ElementParameterType pType = (ElementParameterType) listParamType.get(j);
      if (pType != null) {
        String pTypeName = pType.getName();
        if (pTypeName != null && !"".equals(pTypeName)) {
          IElementParameter param = elemParam.getElementParameter(pTypeName);
          if (pTypeName.equals("DB_TYPE")) { // $NON-NLS-1$
            statsDBType = param;
          } else if (pTypeName.equals("DB_VERSION")) { // $NON-NLS-1$
            statsDBVersion = param;
          } else if (pTypeName.equals("DB_TYPE_IMPLICIT_CONTEXT")) { // $NON-NLS-1$
            implicitDBType = param;
          } else if (pTypeName.equals("DB_VERSION_IMPLICIT_CONTEXT")) { // $NON-NLS-1$
            implicitDBVersion = param;
          }
          if (param != null) {
            String name = param.getName();
            param.setContextMode(pType.isContextMode());
            if (param.isReadOnly()
                && !(EParameterName.UNIQUE_NAME.getName().equals(name)
                    || EParameterName.VERSION.getName().equals(name))) {
              continue; // if the parameter is read only, don't load
              // it (this will prevent to overwrite the
              // value)
            }
            String value = null;
            if ("STATANDLOG_USE_PROJECT_SETTINGS".equals(name) // $NON-NLS-1$
                || "IMPLICITCONTEXT_USE_PROJECT_SETTINGS".equals(name)) { // $NON-NLS-1$
              Object value2 = param.getValue();
              if (value2 != null) {
                value = value2.toString();
              }
            } else {
              value = pType.getValue();
            }
            if (param.getFieldType().equals(EParameterFieldType.CHECK)
                || param.getFieldType().equals(EParameterFieldType.RADIO)) {
              if (Boolean.FALSE.toString().equalsIgnoreCase(value)
                  || Boolean.TRUE.toString().equalsIgnoreCase(value)
                  || !pType.isContextMode()) {
                Boolean boolean1 = new Boolean(value);
                elemParam.setPropertyValue(pTypeName, boolean1);
              } else {
                elemParam.setPropertyValue(pTypeName, value);
              }
              // if (EParameterName.ACTIVATE.getName().equals(param.getName())) {
              // if ((elemParam instanceof Node) && !boolean1) {
              // ((Node) elemParam).setDummy(!boolean1);
              // }
              // }
            } else if (param.getFieldType().equals(EParameterFieldType.CLOSED_LIST)) {
              boolean valueSet = false;
              if (!ArrayUtils.contains(param.getListItemsValue(), value)) {
                if (ArrayUtils.contains(param.getListItemsDisplayName(), value)) {
                  valueSet = true;
                  int index = ArrayUtils.indexOf(param.getListItemsDisplayName(), value);
                  if (index > -1) {
                    elemParam.setPropertyValue(pTypeName, param.getListItemsValue()[index]);
                  }
                } else if (value.equals("")
                    && name != null
                    && (name.equals("LOAD_NEW_VARIABLE") || name.equals("NOT_LOAD_OLD_VARIABLE"))) {
                  valueSet = true;
                  elemParam.setPropertyValue(pTypeName, param.getListItemsValue()[1]);
                }
              }
              if (!valueSet) {
                elemParam.setPropertyValue(pTypeName, value);
              }
            } else if (param.getFieldType().equals(EParameterFieldType.TABLE)) {
              List<Map<String, Object>> tableValues = new ArrayList<Map<String, Object>>();
              String[] codeList = param.getListItemsDisplayCodeName();
              Map<String, Object> lineValues = null;
              for (ElementValueType elementValue :
                  (List<ElementValueType>) pType.getElementValue()) {
                boolean found = false;
                int length = codeList.length;
                if (length > 0) {
                  for (int i = 0; i < length && !found; i++) {
                    if (codeList[i].equals(elementValue.getElementRef())) {
                      found = true;
                    }
                  }
                }
                IElementParameter tmpParam = null;
                for (Object o : param.getListItemsValue()) {
                  if (o instanceof IElementParameter) {
                    IElementParameter tableParam = (IElementParameter) o;
                    if (tableParam.getName().equals(elementValue.getElementRef())) {
                      tmpParam = tableParam;
                      break;
                    }
                  }
                }
                if (found) {
                  if ((lineValues == null)
                      || (lineValues.get(elementValue.getElementRef()) != null)) {
                    lineValues = new HashMap<String, Object>();
                    tableValues.add(lineValues);
                  }
                  String elemValue = elementValue.getValue();
                  if (tmpParam != null
                      && EParameterFieldType.PASSWORD.equals(tmpParam.getFieldType())) {
                    elemValue = elementValue.getRawValue();
                  }
                  lineValues.put(elementValue.getElementRef(), elemValue);
                  if (elementValue.getType() != null) {
                    lineValues.put(
                        elementValue.getElementRef() + IEbcdicConstant.REF_TYPE,
                        elementValue.getType());
                  }
                }
              }
              elemParam.setPropertyValue(pTypeName, tableValues);
            } else if (param.getFieldType().equals(EParameterFieldType.PASSWORD)) {
              param.setValue(pType.getRawValue());
            } else if (param.getFieldType().equals(EParameterFieldType.ENCODING_TYPE)) {
              // fix for bug 2193
              boolean setToCustom = false;
              if (EmfComponent.REPOSITORY.equals(
                      elemParam.getPropertyValue(EParameterName.PROPERTY_TYPE.getName()))
                  && param.getRepositoryValue() != null
                  && param.getRepositoryValue().equals("ENCODING")) { // $NON-NLS-1$
                setToCustom = true;
              }
              String tempValue = null;
              IElementParameter iElementParameter = null;
              Map<String, IElementParameter> childParameters = param.getChildParameters();
              if (childParameters != null) {
                iElementParameter = childParameters.get(EParameterName.ENCODING_TYPE.getName());
                if (iElementParameter != null) {
                  tempValue = (String) iElementParameter.getValue();
                }
              }
              if (tempValue != null && !tempValue.equals(EmfComponent.ENCODING_TYPE_CUSTOM)) {
                tempValue = tempValue.replaceAll("'", ""); // $NON-NLS-1$ //$NON-NLS-2$
                tempValue = tempValue.replaceAll("\"", ""); // $NON-NLS-1$ //$NON-NLS-2$
                tempValue = TalendTextUtils.addQuotes(tempValue);
                if (!tempValue.equals(value)) {
                  setToCustom = true;
                }
              }

              if (iElementParameter != null && setToCustom) {
                iElementParameter.setValue(EmfComponent.ENCODING_TYPE_CUSTOM);
              }
              elemParam.setPropertyValue(pTypeName, value);
              // end of fix for bug 2193
            } else if (!param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE)) {
              if (param.getRepositoryValue() != null
                  && !param.getFieldType().equals(EParameterFieldType.PROPERTY_TYPE)) {
                if (repositoryParam != null
                    && EmfComponent.REPOSITORY.equals(repositoryParam.getValue())) {
                  param.setRepositoryValueUsed(true);
                } else {
                  param.setRepositoryValueUsed(false);
                }
              }
              elemParam.setPropertyValue(pTypeName, value);
            }
          } else if (UpdateTheJobsActionsOnTable.isClear
              && "CLEAR_TABLE".equals(pTypeName) // $NON-NLS-1$
              && "true".equals(pType.getValue()) // $NON-NLS-1$
              && "NONE"
                  .equals(
                      elemParam
                          .getElementParameter(Process.TABLE_ACTION)
                          .getValue())) { //$NON-NLS-1$
            elemParam.setPropertyValue(Process.TABLE_ACTION, "CLEAR"); // $NON-NLS-1$
            UpdateTheJobsActionsOnTable.isClear = false;
          }
        }
      }
    }

    // update combo list for dbversion
    if (statsDBType != null && statsDBVersion != null) {
      JobSettingVersionUtil.setDbVersion(
          statsDBVersion,
          String.valueOf(statsDBType.getValue()),
          String.valueOf(statsDBVersion.getValue()));
    }
    if (implicitDBType != null && implicitDBVersion != null) {
      JobSettingVersionUtil.setDbVersion(
          implicitDBVersion,
          String.valueOf(implicitDBType.getValue()),
          String.valueOf(implicitDBVersion.getValue()));
    }
  }
コード例 #6
0
  @Override
  public void execute() {
    if (result == null) {
      return;
    }
    Object job = result.getJob();
    if (job == null) {
      return;
    }
    if (job instanceof IProcess2) {
      Process process = (Process) job;

      EComponentCategory category = null;
      IUpdateItemType updateType = result.getUpdateType();
      if (updateType instanceof EUpdateItemType) {
        switch ((EUpdateItemType) updateType) {
          case JOB_PROPERTY_EXTRA:
            category = EComponentCategory.EXTRA;
            break;
          case JOB_PROPERTY_STATS_LOGS:
            category = EComponentCategory.STATSANDLOGS;
            break;
          case JOB_PROPERTY_HEADERFOOTER:
            category = EComponentCategory.HEADERFOOTER;
            break;
          case JOB_PROPERTY_MAPREDUCE:
            category = EComponentCategory.MAPREDUCE_JOB_CONFIG_FOR_HADOOP;
            break;
          default:
        }
        if (category == EComponentCategory.HEADERFOOTER) {
          if (result.getResultType() == EUpdateResult.UPDATE) {

            if (result.isChecked()) {
              for (IElementParameter param : process.getElementParameters()) {
                if (param.getCategory() == EComponentCategory.HEADERFOOTER) {
                  IElementParameter headerIDParameter =
                      process.getElementParameter(EParameterName.HEADERFOOTER_HEADERID.getName());
                  if (headerIDParameter != null) {
                    IRepositoryViewObject lastVersion =
                        UpdateRepositoryUtils.getRepositoryObjectById(
                            (String) headerIDParameter.getValue());
                    HeaderFooterConnection repositoryConnection = null;
                    if (lastVersion != null) {
                      final Item item = lastVersion.getProperty().getItem();
                      if (item != null && item instanceof ConnectionItem) {
                        repositoryConnection =
                            (HeaderFooterConnection)
                                ((HeaderFooterConnectionItem) item).getConnection();
                        if (repositoryConnection != null) {
                          Boolean isHeader = repositoryConnection.isIsHeader();
                          String libraries = repositoryConnection.getLibraries();
                          String mainCode = repositoryConnection.getMainCode();
                          String imports = repositoryConnection.getImports();
                          process
                              .getElementParameter(EParameterName.HEADER_ENABLED.getName())
                              .setValue(isHeader);
                          process
                              .getElementParameter(EParameterName.HEADER_LIBRARY.getName())
                              .setValue(libraries);
                          process
                              .getElementParameter(EParameterName.HEADER_CODE.getName())
                              .setValue(mainCode);
                          process
                              .getElementParameter(EParameterName.HEADER_IMPORT.getName())
                              .setValue(imports);
                        }
                      }
                    }
                  }

                  IElementParameter footerIDParameter =
                      process.getElementParameter(EParameterName.HEADERFOOTER_FOOTERID.getName());
                  if (footerIDParameter != null) {
                    IRepositoryViewObject lastVersion =
                        UpdateRepositoryUtils.getRepositoryObjectById(
                            (String) footerIDParameter.getValue());
                    HeaderFooterConnection repositoryConnection = null;
                    if (lastVersion != null) {
                      final Item item = lastVersion.getProperty().getItem();
                      if (item != null && item instanceof ConnectionItem) {
                        repositoryConnection =
                            (HeaderFooterConnection)
                                ((HeaderFooterConnectionItem) item).getConnection();
                        if (repositoryConnection != null) {
                          Boolean isHeader = repositoryConnection.isIsHeader();
                          String libraries = repositoryConnection.getLibraries();
                          String mainCode = repositoryConnection.getMainCode();
                          String imports = repositoryConnection.getImports();
                          process
                              .getElementParameter(EParameterName.FOOTER_ENABLED.getName())
                              .setValue(!isHeader);
                          process
                              .getElementParameter(EParameterName.FOOTER_LIBRARY.getName())
                              .setValue(libraries);
                          process
                              .getElementParameter(EParameterName.FOOTER_CODE.getName())
                              .setValue(mainCode);
                          process
                              .getElementParameter(EParameterName.FOOTER_IMPORT.getName())
                              .setValue(imports);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        } else if (category != null) {
          boolean repository = false;

          if (result.getResultType() == EUpdateResult.UPDATE) {
            // upgrade from repository
            if (result.isChecked()) {
              IElementParameter property =
                  process.getElementParameterFromField(EParameterFieldType.PROPERTY_TYPE, category);
              if (property != null) {
                Map<String, IElementParameter> childParameters = property.getChildParameters();
                if (childParameters != null) {
                  IElementParameter elementParameter =
                      childParameters.get(EParameterName.PROPERTY_TYPE.getName());
                  // is repository
                  if (elementParameter != null
                      && EmfComponent.REPOSITORY.equals(elementParameter.getValue())) {
                    for (IElementParameter param : process.getElementParameters()) {
                      if (param.getCategory() != category) {
                        continue;
                      }
                      String repositoryValue = param.getRepositoryValue();
                      if (param.isShow(process.getElementParameters())
                          && (repositoryValue != null)
                          && (!param.getName().equals(EParameterName.PROPERTY_TYPE.getName()))) {
                        Object objectValue =
                            RepositoryToComponentProperty.getValue(
                                (org.talend.core.model.metadata.builder.connection.Connection)
                                    result.getParameter(),
                                repositoryValue,
                                null);
                        if (objectValue != null) {
                          if (param.getFieldType().equals(EParameterFieldType.CLOSED_LIST)
                              && repositoryValue.equals(UpdatesConstants.TYPE)) {
                            boolean found = false;
                            String[] items = param.getListRepositoryItems();
                            for (int i = 0; (i < items.length) && (!found); i++) {
                              if (objectValue.equals(items[i])) {
                                found = true;
                                process.setPropertyValue(
                                    param.getName(), param.getListItemsValue()[i]);
                              }
                            }
                          } else if (EParameterName.HADOOP_ADVANCED_PROPERTIES
                              .getName()
                              .equals(param.getName())) {
                            List<Map> list = (ArrayList) param.getValue();
                            for (Map map : list) {
                              if (map.get("BUILDIN") != null && map.get("BUILDIN").equals("TRUE")) {
                                if (objectValue instanceof List) {
                                  ((List) objectValue).add(map);
                                }
                              }
                            }
                            process.setPropertyValue(param.getName(), objectValue);

                          } else {
                            process.setPropertyValue(param.getName(), objectValue);
                          }
                          param.setRepositoryValueUsed(true);
                          param.setReadOnly(true);
                          repository = true;
                        }
                      }
                    }
                  }
                }
              }
            }
          }
          if (!repository) {
            IElementParameter property =
                process.getElementParameterFromField(EParameterFieldType.PROPERTY_TYPE, category);
            if (property != null) {
              Map<String, IElementParameter> childParameters = property.getChildParameters();
              if (childParameters != null) {
                IElementParameter elementParameter =
                    childParameters.get(EParameterName.PROPERTY_TYPE.getName());
                elementParameter.setValue(EmfComponent.BUILTIN);
              }
            }

            // built-in
            IElementParameter dbTypeParam = null;
            IElementParameter impliciteDbType = null;
            for (IElementParameter param : process.getElementParameters()) {
              if (param.getCategory() != category) {
                continue;
              }
              String repositoryValue = param.getRepositoryValue();
              if (param.isShow(process.getElementParameters()) && (repositoryValue != null)) {
                // for mysql db verion
                if (EParameterName.DB_TYPE.getName().equals(param.getName())
                    && "TYPE".equals(repositoryValue)) {
                  dbTypeParam = param;
                }
                if ("DB_TYPE_IMPLICIT_CONTEXT".equals(param.getName())
                    && "TYPE".equals(repositoryValue)) {
                  impliciteDbType = param;
                }
                if (EParameterName.DB_VERSION.getName().equals(repositoryValue)
                    && dbTypeParam != null
                    && dbTypeParam.getValue() != null) {
                  final int indexOfItem =
                      dbTypeParam.getIndexOfItemFromList(dbTypeParam.getValue().toString());
                  String dbType = dbTypeParam.getListItemsDisplayCodeName()[indexOfItem];
                  setDBVersionForMysql(param, dbType);
                } else if (EParameterName.DB_VERSION.getName().equals(repositoryValue)
                    && impliciteDbType != null
                    && impliciteDbType.getValue() != null) {
                  final int indexOfItem =
                      impliciteDbType.getIndexOfItemFromList(impliciteDbType.getValue().toString());
                  String dbType = impliciteDbType.getListItemsDisplayCodeName()[indexOfItem];
                  setDBVersionForMysql(param, dbType);
                }
                param.setRepositoryValueUsed(false);
                param.setReadOnly(false);
              }
            }
          }
        }
      } // else { // for extension
    }
  }