nus-yam/ex-repair huggingface dataset:
Program: 108604
Project: 108604
Buggy source:
/** 
 * Creates a new instance
 * @param parent
 * @param model
 */
public HierarchyWizardEditorGroup(final Composite parent,final HierarchyWizardModelGrouping<T> model){
  this.model=model;
  this.model.register(this);
  final Composite composite=new Composite(parent,SWT.NONE);
  composite.setLayout(SWTUtil.createGridLayout(2,true));
  composite.setLayoutData(SWTUtil.createFillHorizontallyGridData());
  this.editorFunction=new HierarchyWizardEditorFunction<T>(this,model,composite,false);
  createLabel(composite,"String_Node_Str");
  this.editorSize=new EditorString(composite){
    @Override public boolean accepts(    final String s){
      if (group == null)       return false;
      try {
        int i=Integer.parseInt(s);
        return i > 0;
      }
 catch (      NumberFormatException e) {
        return false;
      }
    }
    @Override public String getValue(){
      if (group == null)       return "String_Node_Str";
 else       return String.valueOf(group.size);
    }
    @Override public void setValue(    final String s){
      if (group != null) {
        if (group.size != Integer.valueOf(s)) {
          group.size=Integer.valueOf(s);
          model.update(HierarchyWizardEditorGroup.this);
        }
      }
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Creates a new instance
 * @param parent
 * @param model
 */
public HierarchyWizardEditorGroup(final Composite parent,final HierarchyWizardModelGrouping<T> model){
  this.model=model;
  this.model.register(this);
  composite=new Composite(parent,SWT.NONE);
  composite.setLayout(SWTUtil.createGridLayout(2,true));
  composite.setLayoutData(SWTUtil.createFillHorizontallyGridData());
  this.editorFunction=new HierarchyWizardEditorFunction<T>(this,model,composite,false);
  createLabel(composite,"String_Node_Str");
  this.editorSize=new EditorString(composite){
    @Override public boolean accepts(    final String s){
      if (group == null)       return false;
      try {
        int i=Integer.parseInt(s);
        return i > 0;
      }
 catch (      NumberFormatException e) {
        return false;
      }
    }
    @Override public String getValue(){
      if (group == null)       return "String_Node_Str";
 else       return String.valueOf(group.size);
    }
    @Override public void setValue(    final String s){
      if (group != null) {
        if (group.size != Integer.valueOf(s)) {
          group.size=Integer.valueOf(s);
          model.update(HierarchyWizardEditorGroup.this);
        }
      }
    }
  }
;
}
Program: 108605
Project: 108605
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingGroup) {
    this.group=(HierarchyWizardGroupingGroup<T>)model.getSelectedElement();
    this.editorFunction.setFunction(group.function);
    this.editorSize.update();
    SWTUtil.enable(editorSize.getControl());
  }
 else {
    this.group=null;
    this.editorFunction.setFunction(null);
    this.editorSize.update();
    SWTUtil.disable(editorSize.getControl());
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingGroup) {
    this.group=(HierarchyWizardGroupingGroup<T>)model.getSelectedElement();
    this.editorFunction.setFunction(group.function);
    this.editorSize.update();
    SWTUtil.enable(editorSize.getControl());
    SWTUtil.enable(composite);
  }
 else {
    this.group=null;
    this.editorFunction.setFunction(null);
    this.editorSize.update();
    SWTUtil.disable(editorSize.getControl());
    SWTUtil.disable(composite);
  }
}
Program: 108607
Project: 108607
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingInterval) {
    this.interval=(HierarchyWizardGroupingInterval<T>)model.getSelectedElement();
    this.editorFunction.setFunction(this.interval.function);
    this.editorMin.update();
    this.editorMax.update();
    if (model.isFirst(this.interval)) {
      SWTUtil.enable(editorMin.getControl());
    }
 else {
      SWTUtil.disable(editorMin.getControl());
    }
    if (model.isLast(this.interval)) {
      SWTUtil.enable(editorMax.getControl());
    }
 else {
      SWTUtil.disable(editorMax.getControl());
    }
  }
 else {
    this.interval=null;
    this.editorFunction.setFunction(null);
    SWTUtil.disable(editorMin.getControl());
    SWTUtil.disable(editorMax.getControl());
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingInterval) {
    this.interval=(HierarchyWizardGroupingInterval<T>)model.getSelectedElement();
    this.editorFunction.setFunction(this.interval.function);
    this.editorMin.update();
    this.editorMax.update();
    if (model.isFirst(this.interval)) {
      SWTUtil.enable(editorMin.getControl());
    }
 else {
      SWTUtil.disable(editorMin.getControl());
    }
    if (model.isLast(this.interval)) {
      SWTUtil.enable(editorMax.getControl());
    }
 else {
      SWTUtil.disable(editorMax.getControl());
    }
    SWTUtil.enable(composite);
  }
 else {
    this.interval=null;
    this.editorFunction.setFunction(null);
    SWTUtil.disable(editorMin.getControl());
    SWTUtil.disable(editorMax.getControl());
    SWTUtil.disable(composite);
  }
}
Program: 108609
Project: 108609
Buggy source:
/** 
 * Updates the model with a new specification
 * @param builder
 */
public void parse(HierarchyBuilder<T> builder) throws IllegalArgumentException {
  if (type == Type.INTERVAL_BASED) {
    if (intervalModel != null) {
      this.intervalModel.parse((HierarchyBuilderIntervalBased<T>)builder);
      this.type=Type.INTERVAL_BASED;
    }
  }
 else   if (type == Type.ORDER_BASED) {
    this.orderModel.parse((HierarchyBuilderOrderBased<T>)builder);
    this.type=Type.ORDER_BASED;
  }
 else   if (type == Type.REDACTION_BASED) {
    this.redactionModel.parse(builder);
    this.type=Type.REDACTION_BASED;
  }
 else {
    throw new IllegalArgumentException("String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Updates the model with a new specification
 * @param builder
 */
public void parse(HierarchyBuilder<T> builder) throws IllegalArgumentException {
  if (builder.getType() == Type.INTERVAL_BASED) {
    if (intervalModel != null) {
      this.intervalModel.parse((HierarchyBuilderIntervalBased<T>)builder);
      this.type=Type.INTERVAL_BASED;
    }
  }
 else   if (builder.getType() == Type.ORDER_BASED) {
    this.orderModel.parse((HierarchyBuilderOrderBased<T>)builder);
    this.type=Type.ORDER_BASED;
  }
 else   if (builder.getType() == Type.REDACTION_BASED) {
    this.redactionModel.parse(builder);
    this.type=Type.REDACTION_BASED;
  }
 else {
    throw new IllegalArgumentException("String_Node_Str");
  }
}
Program: 108610
Project: 108610
Buggy source:
/** 
 * Creates a new instance
 * @param parent
 * @param model
 */
public HierarchyWizardEditorGroup(final Composite parent,final HierarchyWizardModelGrouping<T> model){
  this.model=model;
  this.model.register(this);
  composite=new Composite(parent,SWT.NONE);
  composite.setLayout(SWTUtil.createGridLayout(2,true));
  composite.setLayoutData(SWTUtil.createFillHorizontallyGridData());
  this.editorFunction=new HierarchyWizardEditorFunction<T>(this,model,composite,false);
  createLabel(composite,"String_Node_Str");
  this.editorSize=new EditorString(composite){
    @Override public boolean accepts(    final String s){
      if (group == null)       return false;
      try {
        int i=Integer.parseInt(s);
        return i > 0;
      }
 catch (      NumberFormatException e) {
        return false;
      }
    }
    @Override public String getValue(){
      if (group == null)       return "String_Node_Str";
 else       return String.valueOf(group.size);
    }
    @Override public void setValue(    final String s){
      if (group != null) {
        if (group.size != Integer.valueOf(s)) {
          group.size=Integer.valueOf(s);
          model.update(HierarchyWizardEditorGroup.this);
        }
      }
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Creates a new instance
 * @param parent
 * @param model
 */
public HierarchyWizardEditorGroup(final Composite parent,final HierarchyWizardModelGrouping<T> model){
  this.model=model;
  this.model.register(this);
  Composite composite=new Composite(parent,SWT.NONE);
  composite.setLayout(SWTUtil.createGridLayout(2,true));
  composite.setLayoutData(SWTUtil.createFillHorizontallyGridData());
  this.editorFunction=new HierarchyWizardEditorFunction<T>(this,model,composite,false);
  createLabel(composite,"String_Node_Str");
  this.editorSize=new EditorString(composite){
    @Override public boolean accepts(    final String s){
      if (group == null)       return false;
      try {
        int i=Integer.parseInt(s);
        return i > 0;
      }
 catch (      NumberFormatException e) {
        return false;
      }
    }
    @Override public String getValue(){
      if (group == null)       return "String_Node_Str";
 else       return String.valueOf(group.size);
    }
    @Override public void setValue(    final String s){
      if (group != null) {
        if (group.size != Integer.valueOf(s)) {
          group.size=Integer.valueOf(s);
          model.update(HierarchyWizardEditorGroup.this);
        }
      }
    }
  }
;
}
Program: 108611
Project: 108611
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingGroup) {
    this.group=(HierarchyWizardGroupingGroup<T>)model.getSelectedElement();
    this.editorFunction.setFunction(group.function);
    this.editorSize.update();
    SWTUtil.enable(editorSize.getControl());
    SWTUtil.enable(composite);
  }
 else {
    this.group=null;
    this.editorFunction.setFunction(null);
    this.editorSize.update();
    SWTUtil.disable(editorSize.getControl());
    SWTUtil.disable(composite);
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingGroup) {
    this.group=(HierarchyWizardGroupingGroup<T>)model.getSelectedElement();
    this.editorFunction.setFunction(group.function);
    this.editorSize.update();
    SWTUtil.enable(editorSize.getControl());
    SWTUtil.enable(this.editorFunction.getControl1());
    SWTUtil.enable(this.editorFunction.getControl2());
  }
 else {
    this.group=null;
    this.editorFunction.setFunction(null);
    this.editorSize.update();
    SWTUtil.disable(editorSize.getControl());
    SWTUtil.disable(this.editorFunction.getControl1());
    SWTUtil.disable(this.editorFunction.getControl2());
  }
}
Program: 108613
Project: 108613
Buggy source:
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingInterval) {
    this.interval=(HierarchyWizardGroupingInterval<T>)model.getSelectedElement();
    this.editorFunction.setFunction(this.interval.function);
    this.editorMin.update();
    this.editorMax.update();
    if (model.isFirst(this.interval)) {
      SWTUtil.enable(editorMin.getControl());
    }
 else {
      SWTUtil.disable(editorMin.getControl());
    }
    if (model.isLast(this.interval)) {
      SWTUtil.enable(editorMax.getControl());
    }
 else {
      SWTUtil.disable(editorMax.getControl());
    }
    SWTUtil.enable(composite);
  }
 else {
    this.interval=null;
    this.editorFunction.setFunction(null);
    SWTUtil.disable(editorMin.getControl());
    SWTUtil.disable(editorMax.getControl());
    SWTUtil.disable(composite);
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") @Override public void update(){
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingInterval) {
    this.interval=(HierarchyWizardGroupingInterval<T>)model.getSelectedElement();
    this.editorFunction.setFunction(this.interval.function);
    this.editorMin.update();
    this.editorMax.update();
    if (model.isFirst(this.interval)) {
      SWTUtil.enable(editorMin.getControl());
    }
 else {
      SWTUtil.disable(editorMin.getControl());
    }
    if (model.isLast(this.interval)) {
      SWTUtil.enable(editorMax.getControl());
    }
 else {
      SWTUtil.disable(editorMax.getControl());
    }
    SWTUtil.enable(this.editorFunction.getControl1());
    SWTUtil.enable(this.editorFunction.getControl2());
  }
 else {
    this.interval=null;
    this.editorFunction.setFunction(null);
    SWTUtil.disable(editorMin.getControl());
    SWTUtil.disable(editorMax.getControl());
    SWTUtil.disable(this.editorFunction.getControl1());
    SWTUtil.disable(this.editorFunction.getControl2());
  }
}
Program: 108615
Project: 108615
Buggy source:
/** 
 * Returns statistics about the groups
 * @return
 */
public abstract GroupStatistics getGroupStatistics();

Fixed version (ground truth):
/** 
 * Returns statistics about the groups
 * @return
 */
public abstract GroupStatistics getGroupStatistics(boolean anonymous);
Program: 108616
Project: 108616
Buggy source:
/** 
 * Checks the interval
 * @param type
 * @param min
 * @param max
 */
private <U>void checkInterval(DataType<U> type,U min,U max){
  int cmp=0;
  try {
    cmp=type.compare(type.format(min),type.format(max));
  }
 catch (  Exception e) {
    throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max);
  }
  if (cmp > 0)   throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max+ "String_Node_Str");
}

Fixed version (ground truth):
/** 
 * Checks the interval
 * @param type
 * @param min
 * @param max
 */
private <U>void checkInterval(DataType<U> type,U min,U max){
  int cmp=0;
  try {
    cmp=type.compare(type.format(min),type.format(max));
  }
 catch (  Exception e) {
    throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max);
  }
  if (cmp >= 0)   throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max+ "String_Node_Str");
}
Program: 108618
Project: 108618
Buggy source:
private void actionDeleteColumn(){
  if (null == targetColumn) {
    return;
  }
  base.setRedraw(false);
  int index=table.indexOf(targetColumn);
  TableColumn toRemove=table.getColumn(index);
  toRemove.dispose();
  updateColumnTitles();
  base.setRedraw(true);
  base.redraw();
  targetColumn=null;
  updateArray();
  updateCombos();
  pushHierarchy();
  pushMin();
  pushMax();
}

Fixed version (ground truth):
private void actionDeleteColumn(){
  if (null == targetColumn) {
    return;
  }
  base.setRedraw(false);
  int index=table.indexOf(targetColumn);
  TableColumn toRemove=table.getColumn(index);
  toRemove.dispose();
  updateColumnTitles();
  base.setRedraw(true);
  base.redraw();
  if (table.getColumnCount() == 0) {
    actionClear();
  }
  targetColumn=null;
  updateArray();
  updateCombos();
  pushHierarchy();
  pushMin();
  pushMax();
}
Program: 108620
Project: 108620
Buggy source:
public void setPath(final String path){
  this.path=path;
  setModified();
}

Fixed version (ground truth):
public void setPath(final String path){
  this.path=path;
}
Program: 108621
Project: 108621
Buggy source:
@SuppressWarnings("String_Node_Str") public void show(int x,int y){
  if (model.getSelectedElement() == null) {
    return;
  }
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingInterval) {
    if (model.getIntervals().size() == 1) {
      this.remove.setEnabled(false);
    }
 else {
      this.remove.setEnabled(true);
    }
    if (model.isFirst((HierarchyWizardGroupingInterval<T>)model.getSelectedElement())) {
      this.addBefore.setEnabled(true);
      this.mergeDown.setEnabled(false);
    }
 else {
      this.addBefore.setEnabled(false);
      this.mergeDown.setEnabled(true);
    }
    if (model.isLast((HierarchyWizardGroupingInterval<T>)model.getSelectedElement())) {
      this.addAfter.setEnabled(true);
      this.mergeUp.setEnabled(false);
    }
 else {
      this.addAfter.setEnabled(false);
      this.mergeUp.setEnabled(true);
    }
    this.addRight.setEnabled(true);
  }
 else   if (model.getSelectedElement() instanceof HierarchyWizardGroupingGroup) {
    if (model.isShowIntervals() && model.getModelGroups().size() == 1 && model.getModelGroups().get(0).size() == 1) {
      this.remove.setEnabled(false);
    }
 else {
      this.remove.setEnabled(true);
    }
    this.addBefore.setEnabled(true);
    this.addAfter.setEnabled(true);
    this.addRight.setEnabled(true);
    this.mergeUp.setEnabled(false);
    this.mergeDown.setEnabled(false);
  }
  menu.setLocation(composite.toDisplay(x,y));
  menu.setVisible(true);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void show(int x,int y){
  if (model.getSelectedElement() == null) {
    return;
  }
  if (model.getSelectedElement() instanceof HierarchyWizardGroupingInterval) {
    HierarchyWizardGroupingInterval<T> interval=(HierarchyWizardGroupingInterval<T>)model.getSelectedElement();
    if (model.getIntervals().size() == 1) {
      this.remove.setEnabled(false);
    }
 else     if (model.isFirst(interval) || model.isLast(interval)) {
      this.remove.setEnabled(true);
    }
 else {
      this.remove.setEnabled(false);
    }
    if (model.isFirst(interval)) {
      this.addBefore.setEnabled(true);
      this.mergeDown.setEnabled(false);
    }
 else {
      this.addBefore.setEnabled(false);
      this.mergeDown.setEnabled(true);
    }
    if (model.isLast(interval)) {
      this.addAfter.setEnabled(true);
      this.mergeUp.setEnabled(false);
    }
 else {
      this.addAfter.setEnabled(false);
      this.mergeUp.setEnabled(true);
    }
    this.addRight.setEnabled(true);
  }
 else   if (model.getSelectedElement() instanceof HierarchyWizardGroupingGroup) {
    if (model.isShowIntervals()) {
      this.remove.setEnabled(true);
    }
 else {
      if (model.getModelGroups().size() == 1 && model.getModelGroups().get(0).size() == 1) {
        this.remove.setEnabled(false);
      }
 else {
        this.remove.setEnabled(true);
      }
    }
    this.addBefore.setEnabled(true);
    this.addAfter.setEnabled(true);
    this.addRight.setEnabled(true);
    this.mergeUp.setEnabled(false);
    this.mergeDown.setEnabled(false);
  }
  menu.setLocation(composite.toDisplay(x,y));
  menu.setVisible(true);
}
Program: 108623
Project: 108623
Buggy source:
/** 
 * Checks the interval
 * @param type
 * @param min
 * @param max
 */
private <U>void checkInterval(DataType<U> type,U min,U max){
  try {
    if (type.compare(type.format(min),type.format(max)) > 0) {
      throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max+ "String_Node_Str");
    }
  }
 catch (  Exception e) {
    throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max);
  }
}

Fixed version (ground truth):
/** 
 * Checks the interval
 * @param type
 * @param min
 * @param max
 */
private <U>void checkInterval(DataType<U> type,U min,U max){
  int cmp=0;
  try {
    cmp=type.compare(type.format(min),type.format(max));
  }
 catch (  Exception e) {
    throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max);
  }
  if (cmp > 0)   throw new IllegalArgumentException("String_Node_Str" + min + "String_Node_Str"+ max+ "String_Node_Str");
}
Program: 108625
Project: 108625
Buggy source:
/** 
 * Creates a final result from this temporary result
 * @param anonymizer
 * @param handle
 * @param time
 * @return
 */
public ARXResult asResult(ARXConfiguration config,DataHandle handle,long time){
  final ARXLattice flattice=new ARXLattice(lattice,manager.getDataQI().getHeader(),config);
  ((DataHandleInput)handle).setLocked(true);
  return new ARXResult(handle.getRegistry(),this.manager,this.checker,handle.getDefinition(),config,flattice,flattice.getOptimum(),System.currentTimeMillis() - time,suppressionString,removeOutliers);
}

Fixed version (ground truth):
/** 
 * Creates a final result from this temporary result
 * @param anonymizer
 * @param handle
 * @param time
 * @return
 */
public ARXResult asResult(ARXConfiguration config,DataHandle handle,long time){
  final ARXLattice flattice=new ARXLattice(lattice,manager.getDataQI().getHeader(),config);
  ((DataHandleInput)handle).setLocked(true);
  return new ARXResult(handle.getRegistry(),this.manager,this.checker,handle.getDefinition(),config,flattice,System.currentTimeMillis() - time,suppressionString,removeOutliers);
}
Program: 108626
Project: 108626
Buggy source:
/** 
 * Creates a new instance
 * @param registry
 * @param manager
 * @param checker
 * @param definition
 * @param config
 * @param lattice
 * @param optimalNode
 * @param duration
 * @param suppressionString
 * @param removeOutliers
 */
protected ARXResult(DataRegistry registry,DataManager manager,INodeChecker checker,DataDefinition definition,ARXConfiguration config,ARXLattice lattice,ARXNode optimalNode,long duration,String suppressionString,boolean removeOutliers){
  this.registry=registry;
  this.manager=manager;
  this.checker=checker;
  this.definition=definition;
  this.config=config;
  this.lattice=lattice;
  this.optimalNode=optimalNode;
  this.duration=duration;
  this.suppressionString=suppressionString;
  this.removeOutliers=removeOutliers;
}

Fixed version (ground truth):
/** 
 * Creates a new instance
 * @param registry
 * @param manager
 * @param checker
 * @param definition
 * @param config
 * @param lattice
 * @param optimalNode
 * @param duration
 * @param suppressionString
 * @param removeOutliers
 */
protected ARXResult(DataRegistry registry,DataManager manager,INodeChecker checker,DataDefinition definition,ARXConfiguration config,ARXLattice lattice,long duration,String suppressionString,boolean removeOutliers){
  this.registry=registry;
  this.manager=manager;
  this.checker=checker;
  this.definition=definition;
  this.config=config;
  this.lattice=lattice;
  this.optimalNode=lattice.getOptimum();
  this.duration=duration;
  this.suppressionString=suppressionString;
  this.removeOutliers=removeOutliers;
}
Program: 108627
Project: 108627
Buggy source:
@Override @Deprecated public Data transform(final Node node){
  throw new RuntimeException("String_Node_Str");
}

Fixed version (ground truth):
@Override @Deprecated public Data transform(final Node node){
  throw new UnsupportedOperationException("String_Node_Str");
}
Program: 108628
Project: 108628
Buggy source:
@Override @Deprecated public double getInformationLoss(final Node node){
  check(node);
  metric.evaluate(node,currentGroupify);
  return node.getInformationLoss().getValue();
}

Fixed version (ground truth):
@Override @Deprecated public double getInformationLoss(final Node node){
  throw new UnsupportedOperationException("String_Node_Str");
}
Program: 108629
Project: 108629
Buggy source:
/** 
 * Evaluates the metric for the given node
 * @param node The node for which to compute the information loss
 * @param groupify The groupify operator of the previous check
 * @return the double
 */
public final void evaluate(final Node node,final IHashGroupify groupify){
  node.setInformationLoss(this.evaluateInternal(node,groupify));
  if ((globalOptimum == null) || (node.getInformationLoss().compareTo(optimalInformationLoss) < 0) || (node.getInformationLoss().compareTo(optimalInformationLoss) == 0 && node.getLevel() < globalOptimum.getLevel())) {
    this.globalOptimum=node;
    this.optimalInformationLoss=node.getInformationLoss();
  }
}

Fixed version (ground truth):
/** 
 * Evaluates the metric for the given node
 * @param node The node for which to compute the information loss
 * @param groupify The groupify operator of the previous check
 * @return the double
 */
public final void evaluate(final Node node,final IHashGroupify groupify){
  node.setInformationLoss(this.evaluateInternal(node,groupify));
  if (node.isAnonymous() && ((globalOptimum == null) || (node.getInformationLoss().compareTo(optimalInformationLoss) < 0) || (node.getInformationLoss().compareTo(optimalInformationLoss) == 0 && node.getLevel() < globalOptimum.getLevel()))) {
    this.globalOptimum=node;
    this.optimalInformationLoss=node.getInformationLoss();
  }
}
Program: 108630
Project: 108630
Buggy source:
@Override public void setVisible(boolean value){
  if (value) {
    this.model.update();
    Button load=this.wizard.getLoadButton();
    if (load != null)     load.setEnabled(false);
    Button save=this.wizard.getSaveButton();
    if (save != null)     save.setEnabled(true);
  }
  super.setVisible(value);
}

Fixed version (ground truth):
@Override public void setVisible(boolean value){
  if (value) {
    this.model.update();
    Button load=this.wizard.getLoadButton();
    if (load != null)     load.setEnabled(false);
  }
  super.setVisible(value);
}
Program: 108631
Project: 108631
Buggy source:
/** 
 * Returns the created builder
 * @return
 */
public HierarchyWizardResult<T> getResult(){
  return new HierarchyWizardResult<T>(model.getHierarchy(),model.getBuilder());
}

Fixed version (ground truth):
/** 
 * Returns the created builder
 * @return
 */
public HierarchyWizardResult<T> getResult(){
  try {
    return new HierarchyWizardResult<T>(model.getHierarchy(),model.getBuilder());
  }
 catch (  Exception e) {
    return null;
  }
}
Program: 108632
Project: 108632
Buggy source:
/** 
 * Saves the current specification
 */
private void save(){
  final String ERROR_HEADER="String_Node_Str";
  final String ERROR_TEXT="String_Node_Str";
  String file=controller.actionShowSaveFileDialog(getShell(),"String_Node_Str");
  if (file == null)   return;
  HierarchyBuilder<T> builder=null;
  if (getDialog().getCurrentPage() instanceof HierarchyWizardPageOrder) {
    builder=model.getOrderModel().getBuilder();
  }
 else   if (getDialog().getCurrentPage() instanceof HierarchyWizardPageIntervals) {
    builder=model.getIntervalModel().getBuilder();
  }
 else   if (getDialog().getCurrentPage() instanceof HierarchyWizardPageRedaction) {
    builder=model.getRedactionModel().getBuilder();
  }
  try {
    builder.save(file);
  }
 catch (  Exception e) {
    controller.actionShowInfoDialog(getShell(),ERROR_HEADER,ERROR_TEXT + e.getMessage());
    return;
  }
}

Fixed version (ground truth):
/** 
 * Saves the current specification
 */
private void save(){
  final String ERROR_HEADER="String_Node_Str";
  final String ERROR_TEXT="String_Node_Str";
  String file=controller.actionShowSaveFileDialog(getShell(),"String_Node_Str");
  if (file == null)   return;
  try {
    HierarchyBuilder<T> builder=null;
    if (getDialog().getCurrentPage() instanceof HierarchyWizardPageOrder) {
      builder=model.getOrderModel().getBuilder();
    }
 else     if (getDialog().getCurrentPage() instanceof HierarchyWizardPageIntervals) {
      builder=model.getIntervalModel().getBuilder();
    }
 else     if (getDialog().getCurrentPage() instanceof HierarchyWizardPageRedaction) {
      builder=model.getRedactionModel().getBuilder();
    }
    builder.save(file);
  }
 catch (  Exception e) {
    controller.actionShowInfoDialog(getShell(),ERROR_HEADER,ERROR_TEXT + e.getMessage());
    return;
  }
}
Program: 108633
Project: 108633
Buggy source:
/** 
 * Returns the current builder
 * @return
 */
public HierarchyBuilder<T> getBuilder(){
  if (type == Type.INTERVAL_BASED) {
    return intervalModel.getBuilder();
  }
 else   if (type == Type.REDACTION_BASED) {
    return redactionModel.getBuilder();
  }
 else   if (type == Type.ORDER_BASED) {
    return orderModel.getBuilder();
  }
 else {
    throw new IllegalArgumentException("String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * Returns the current builder
 * @return
 */
public HierarchyBuilder<T> getBuilder() throws Exception {
  if (type == Type.INTERVAL_BASED) {
    return intervalModel.getBuilder();
  }
 else   if (type == Type.REDACTION_BASED) {
    return redactionModel.getBuilder();
  }
 else   if (type == Type.ORDER_BASED) {
    return orderModel.getBuilder();
  }
 else {
    throw new IllegalArgumentException("String_Node_Str");
  }
}
Program: 108634
Project: 108634
Buggy source:
/** 
 * Returns the builder currently configured
 * @return
 */
public abstract HierarchyBuilder<T> getBuilder();

Fixed version (ground truth):
/** 
 * Returns the builder currently configured
 * @return
 */
public abstract HierarchyBuilder<T> getBuilder() throws Exception ;
Program: 108635
Project: 108635
Buggy source:
@Override public HierarchyBuilderIntervalBased<T> getBuilder(){
  HierarchyBuilderIntervalBased<T> builder=HierarchyBuilderIntervalBased.create(super.getDataType(),new Range<T>(super.getLowerRange().repeat,super.getLowerRange().snap,super.getLowerRange().label),new Range<T>(super.getUpperRange().repeat,super.getUpperRange().snap,super.getUpperRange().label));
  builder.setAggregateFunction(this.getDefaultFunction());
  for (  HierarchyWizardGroupingInterval<T> interval : super.getIntervals()) {
    builder.addInterval(interval.min,interval.max,interval.function);
  }
  int level=0;
  for (  List<HierarchyWizardGroupingGroup<T>> list : super.getModelGroups()) {
    for (    HierarchyWizardGroupingGroup<T> group : list) {
      builder.getLevel(level).addGroup(group.size,group.function);
    }
    level++;
  }
  return builder;
}

Fixed version (ground truth):
@Override public HierarchyBuilderIntervalBased<T> getBuilder() throws Exception {
  HierarchyBuilderIntervalBased<T> builder=HierarchyBuilderIntervalBased.create(super.getDataType(),new Range<T>(super.getLowerRange().repeat,super.getLowerRange().snap,super.getLowerRange().label),new Range<T>(super.getUpperRange().repeat,super.getUpperRange().snap,super.getUpperRange().label));
  builder.setAggregateFunction(this.getDefaultFunction());
  for (  HierarchyWizardGroupingInterval<T> interval : super.getIntervals()) {
    builder.addInterval(interval.min,interval.max,interval.function);
  }
  int level=0;
  for (  List<HierarchyWizardGroupingGroup<T>> list : super.getModelGroups()) {
    for (    HierarchyWizardGroupingGroup<T> group : list) {
      builder.getLevel(level).addGroup(group.size,group.function);
    }
    level++;
  }
  return builder;
}
Program: 108636
Project: 108636
Buggy source:
@Override protected void build(){
  super.hierarchy=null;
  super.error=null;
  super.groupsizes=null;
  HierarchyBuilderIntervalBased<T> builder=getBuilder();
  String error=builder.isValid();
  if (error != null) {
    super.error=error;
    return;
  }
  try {
    super.groupsizes=builder.prepare(data);
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
  try {
    super.hierarchy=builder.build();
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
}

Fixed version (ground truth):
@Override protected void build(){
  super.hierarchy=null;
  super.error=null;
  super.groupsizes=null;
  HierarchyBuilderIntervalBased<T> builder=null;
  try {
    builder=getBuilder();
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
  String error=builder.isValid();
  if (error != null) {
    super.error=error;
    return;
  }
  try {
    super.groupsizes=builder.prepare(data);
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
  try {
    super.hierarchy=builder.build();
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
}
Program: 108637
Project: 108637
Buggy source:
@Override public HierarchyBuilderOrderBased<T> getBuilder(){
  HierarchyBuilderOrderBased<T> builder=HierarchyBuilderOrderBased.create(super.getDataType(),false);
  builder.setAggregateFunction(this.getDefaultFunction());
  int level=0;
  for (  List<HierarchyWizardGroupingGroup<T>> list : super.getModelGroups()) {
    for (    HierarchyWizardGroupingGroup<T> group : list) {
      builder.getLevel(level).addGroup(group.size,group.function);
    }
    level++;
  }
  return builder;
}

Fixed version (ground truth):
@Override public HierarchyBuilderOrderBased<T> getBuilder() throws Exception {
  HierarchyBuilderOrderBased<T> builder=HierarchyBuilderOrderBased.create(super.getDataType(),false);
  builder.setAggregateFunction(this.getDefaultFunction());
  int level=0;
  for (  List<HierarchyWizardGroupingGroup<T>> list : super.getModelGroups()) {
    for (    HierarchyWizardGroupingGroup<T> group : list) {
      builder.getLevel(level).addGroup(group.size,group.function);
    }
    level++;
  }
  return builder;
}
Program: 108638
Project: 108638
Buggy source:
@Override protected void build(){
  super.hierarchy=null;
  super.error=null;
  super.groupsizes=null;
  HierarchyBuilderOrderBased<T> builder=getBuilder();
  String error=builder.isValid();
  if (error != null) {
    super.error=error;
    return;
  }
  try {
    super.groupsizes=builder.prepare(data);
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
  try {
    super.hierarchy=builder.build();
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
}

Fixed version (ground truth):
@Override protected void build(){
  super.hierarchy=null;
  super.error=null;
  super.groupsizes=null;
  HierarchyBuilderOrderBased<T> builder=null;
  try {
    builder=getBuilder();
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
  String error=builder.isValid();
  if (error != null) {
    super.error=error;
    return;
  }
  try {
    super.groupsizes=builder.prepare(data);
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
  try {
    super.hierarchy=builder.build();
  }
 catch (  Exception e) {
    super.error=e.getMessage();
    return;
  }
}
Program: 108639
Project: 108639
Buggy source:
@Override public void update(){
  if (model.getError() != null) {
    this.setErrorMessage(model.getError());
    finalPage.setGroups(null);
    finalPage.setHierarchy(null);
    this.setPageComplete(false);
  }
 else {
    this.setErrorMessage(null);
    finalPage.setGroups(model.getGroups());
    finalPage.setHierarchy(model.getHierarchy());
    this.setPageComplete(true);
  }
}

Fixed version (ground truth):
@Override public void update(){
  if (model.getError() != null) {
    this.setErrorMessage(model.getError());
    finalPage.setGroups(null);
    finalPage.setHierarchy(null);
    this.setPageComplete(false);
    Button save=this.wizard.getSaveButton();
    if (save != null)     save.setEnabled(false);
  }
 else {
    this.setErrorMessage(null);
    finalPage.setGroups(model.getGroups());
    finalPage.setHierarchy(model.getHierarchy());
    this.setPageComplete(true);
    Button save=this.wizard.getSaveButton();
    if (save != null)     save.setEnabled(true);
  }
}
Program: 108640
Project: 108640
Buggy source:
/** 
 * Create a tab
 * @param tabFolder
 */
private void createGeneralTab(CTabFolder tabFolder){
  CTabItem tabItem1=new CTabItem(tabFolder,SWT.NULL);
  tabItem1.setText("String_Node_Str");
  Composite parent=new Composite(tabFolder,SWT.NULL);
  parent.setLayout(SWTUtil.createGridLayout(2,false));
  parent.setLayoutData(SWTUtil.createFillHorizontallyGridData());
  HierarchyWizardEditorFunction<T> editor=new HierarchyWizardEditorFunction<T>(this,model,parent,true);
  editor.setFunction(model.getDefaultFunction());
  tabItem1.setControl(parent);
}

Fixed version (ground truth):
/** 
 * Create a tab
 * @param tabFolder
 */
private void createGeneralTab(CTabFolder tabFolder){
  CTabItem tabItem1=new CTabItem(tabFolder,SWT.NULL);
  tabItem1.setText("String_Node_Str");
  Composite parent=new Composite(tabFolder,SWT.NULL);
  parent.setLayout(SWTUtil.createGridLayout(2,false));
  parent.setLayoutData(SWTUtil.createFillHorizontallyGridData());
  editor=new HierarchyWizardEditorFunction<T>(this,model,parent,true);
  editor.setFunction(model.getDefaultFunction());
  tabItem1.setControl(parent);
}
Program: 108641
Project: 108641
Buggy source:
@Override public void setFunction(AggregateFunction<T> function){
  model.setDefaultFunction(function);
  model.update();
}

Fixed version (ground truth):
@Override public void setFunction(AggregateFunction<T> function){
  model.setDefaultFunction(function);
  editor.setFunction(function);
  model.update();
}
Program: 108642
Project: 108642
Buggy source:
@Override public void updatePage(){
  model.update();
}

Fixed version (ground truth):
@Override public void updatePage(){
  model.update();
  if (editor != null)   editor.setFunction(model.getDefaultFunction());
}
Program: 108643
Project: 108643
Buggy source:
@Override public void createControl(final Composite parent){
  Composite composite=new Composite(parent,SWT.NONE);
  composite.setLayout(SWTUtil.createGridLayout(1,false));
  @SuppressWarnings("String_Node_Str") HierarchyWizardEditor<Long> component=new HierarchyWizardEditor<Long>(composite,(HierarchyWizardModelGrouping<Long>)model);
  component.setLayoutData(SWTUtil.createFillGridData());
  setControl(composite);
}

Fixed version (ground truth):
@Override public void createControl(final Composite parent){
  Composite composite=new Composite(parent,SWT.NONE);
  composite.setLayout(SWTUtil.createGridLayout(1,false));
  editor=new HierarchyWizardEditor<T>(composite,(HierarchyWizardModelGrouping<T>)model);
  editor.setLayoutData(SWTUtil.createFillGridData());
  setControl(composite);
}
Program: 108644
Project: 108644
Buggy source:
@Override public void updatePage(){
  list.setRedraw(false);
  list.removeAll();
  for (  String s : model.getData()) {
    list.add(s);
  }
  list.setRedraw(true);
  combo.select(getIndexOfDataType(model.getDataType()));
  model.update();
}

Fixed version (ground truth):
@Override public void updatePage(){
  list.setRedraw(false);
  list.removeAll();
  for (  String s : model.getData()) {
    list.add(s);
  }
  list.setRedraw(true);
  combo.select(getIndexOfDataType(model.getDataType()));
  if (editor != null)   editor.setFunction(model.getDefaultFunction());
  model.update();
}
Program: 108645
Project: 108645
Buggy source:
/** 
 * Create the grouping-part of the page
 * @param parent
 */
@SuppressWarnings("String_Node_Str") private void createGroups(Composite parent){
  Group composite=new Group(parent,SWT.NONE);
  composite.setText("String_Node_Str");
  composite.setLayout(SWTUtil.createGridLayout(1,false));
  composite.setLayoutData(SWTUtil.createFillGridData());
  editor=new HierarchyWizardEditor<Long>(composite,(HierarchyWizardModelGrouping<Long>)model);
  editor.setLayoutData(SWTUtil.createFillGridData());
}

Fixed version (ground truth):
/** 
 * Create the grouping-part of the page
 * @param parent
 */
private void createGroups(Composite parent){
  Group composite=new Group(parent,SWT.NONE);
  composite.setText("String_Node_Str");
  composite.setLayout(SWTUtil.createGridLayout(1,false));
  composite.setLayoutData(SWTUtil.createFillGridData());
  editor=new HierarchyWizardEditor<T>(composite,(HierarchyWizardModelGrouping<T>)model);
  editor.setLayoutData(SWTUtil.createFillGridData());
}
Program: 108647
Project: 108647
Buggy source:
/** 
 * Returns a generalization hierarchy for the attribute, if available
 * @param context
 * @param attribute
 * @return
 */
public Hierarchy getHierarchy(Context context,String attribute){
  if (context.config == model.getInputConfig())   return null;
  AttributeType type=model.getOutputDefinition().getAttributeType(attribute);
  if (type instanceof Hierarchy) {
    return (Hierarchy)type;
  }
  for (  HierarchicalDistanceTCloseness t : context.config.getCriteria(HierarchicalDistanceTCloseness.class)) {
    if (t.getAttribute().equals(attribute)) {
      return t.getHierarchy();
    }
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Returns a generalization hierarchy for the attribute, if available
 * @param context
 * @param attribute
 * @return
 */
public Hierarchy getHierarchy(Context context,String attribute){
  if (context.config == null || context.config == model.getInputConfig() || model.getOutputDefinition() == null) {
    return null;
  }
  AttributeType type=model.getOutputDefinition().getAttributeType(attribute);
  if (type instanceof Hierarchy) {
    return (Hierarchy)type;
  }
  for (  HierarchicalDistanceTCloseness t : context.config.getCriteria(HierarchicalDistanceTCloseness.class)) {
    if (t.getAttribute().equals(attribute)) {
      return t.getHierarchy();
    }
  }
  return null;
}
Program: 108648
Project: 108648
Buggy source:
@Override public Data transformAndMarkOutliers(final Node node){
  currentGroupify.clear();
  currentGroupify=transformer.apply(0L,node.getTransformation(),currentGroupify);
  node.setAnonymous(currentGroupify.isAnonymous());
  if (!node.isChecked()) {
    node.setChecked();
    metric.evaluate(node,currentGroupify);
    node.setTagged();
  }
  if (config.getAbsoluteMaxOutliers() != 0) {
    currentGroupify.markOutliers(transformer.getBuffer());
  }
  return getBuffer();
}

Fixed version (ground truth):
@Override public Data transformAndMarkOutliers(final Node node){
  currentGroupify.clear();
  currentGroupify=transformer.apply(0L,node.getTransformation(),currentGroupify);
  node.setAnonymous(currentGroupify.isAnonymous());
  node.setChecked();
  node.setTagged();
  if (node.getInformationLoss() == null) {
    metric.evaluate(node,currentGroupify);
  }
  if (node.isAnonymous() && config.getAbsoluteMaxOutliers() != 0) {
    currentGroupify.markOutliers(transformer.getBuffer());
  }
  return getBuffer();
}
Program: 108649
Project: 108649
Buggy source:
@Override protected InformationLossDefault evaluateInternal(final Node node,final IHashGroupify g){
  double value=0;
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (m.isNotOutlier) {
      value+=((double)m.count * (double)m.count);
    }
 else {
      value+=((double)rowCount * (double)m.count);
    }
    m=m.nextOrdered;
  }
  return new InformationLossDefault(value);
}

Fixed version (ground truth):
@Override protected InformationLossDefault evaluateInternal(final Node node,final IHashGroupify g){
  final boolean anonymous=node.isAnonymous();
  double value=0;
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (!anonymous || m.isNotOutlier) {
      value+=((double)m.count * (double)m.count);
    }
 else {
      value+=((double)rowCount * (double)m.count);
    }
    m=m.nextOrdered;
  }
  return new InformationLossDefault(value);
}
Program: 108650
Project: 108650
Buggy source:
@Override @SuppressWarnings("String_Node_Str") protected InformationLossDefault evaluateInternal(final Node node,final IHashGroupify g){
  final double originalInfoLoss=super.evaluateInternal(node,g).getValue();
  double suppressedTuples=0;
  double additionalInfoLoss=0;
  int key;
  Integer val;
  final Map<Integer,Integer>[] original=new Map[node.getTransformation().length];
  for (int i=0; i < original.length; i++) {
    original[i]=new HashMap<Integer,Integer>();
  }
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (!m.isNotOutlier && m.count > 0) {
      suppressedTuples+=m.count;
      for (int i=0; i < original.length; i++) {
        key=m.key[i];
        val=original[i].get(key);
        if (val == null) {
          original[i].put(key,m.count);
        }
 else {
          original[i].put(key,m.count + val);
        }
      }
    }
    m=m.nextOrdered;
  }
  if (suppressedTuples != 0) {
    for (int i=0; i < original.length; i++) {
      for (      final double count : original[i].values()) {
        additionalInfoLoss+=count * MetricEntropy.log2(count / suppressedTuples);
      }
    }
  }
  return new InformationLossDefault(originalInfoLoss - additionalInfoLoss);
}

Fixed version (ground truth):
@Override @SuppressWarnings("String_Node_Str") protected InformationLossDefault evaluateInternal(final Node node,final IHashGroupify g){
  final InformationLossDefault originalInfoLossDefault=super.evaluateInternal(node,g);
  if (!node.isAnonymous())   return originalInfoLossDefault;
  final double originalInfoLoss=originalInfoLossDefault.getValue();
  double suppressedTuples=0;
  double additionalInfoLoss=0;
  int key;
  Integer val;
  final Map<Integer,Integer>[] original=new Map[node.getTransformation().length];
  for (int i=0; i < original.length; i++) {
    original[i]=new HashMap<Integer,Integer>();
  }
  HashGroupifyEntry m=g.getFirstEntry();
  while (m != null) {
    if (!m.isNotOutlier && m.count > 0) {
      suppressedTuples+=m.count;
      for (int i=0; i < original.length; i++) {
        key=m.key[i];
        val=original[i].get(key);
        if (val == null) {
          original[i].put(key,m.count);
        }
 else {
          original[i].put(key,m.count + val);
        }
      }
    }
    m=m.nextOrdered;
  }
  if (suppressedTuples != 0) {
    for (int i=0; i < original.length; i++) {
      for (      final double count : original[i].values()) {
        additionalInfoLoss+=count * MetricEntropy.log2(count / suppressedTuples);
      }
    }
  }
  return new InformationLossDefault(originalInfoLoss - additionalInfoLoss);
}
Program: 108651
Project: 108651
Buggy source:
/** 
 * File->Export hierarchy
 */
public void actionMenuFileExportHierarchy(){
  if (model == null) {
    main.showInfoDialog(main.getShell(),Resources.getMessage("String_Node_Str"),Resources.getMessage("String_Node_Str"));
    return;
  }
 else   if (!(model.isQuasiIdentifierSelected() || model.isSensitiveAttributeSelected())) {
    main.showInfoDialog(main.getShell(),Resources.getMessage("String_Node_Str"),Resources.getMessage("String_Node_Str"));
    return;
  }
  String file=main.showSaveFileDialog(main.getShell(),"String_Node_Str");
  if (file == null) {
    return;
  }
  if (!file.endsWith("String_Node_Str")) {
    file=file + "String_Node_Str";
  }
  try {
    final CSVDataOutput out=new CSVDataOutput(file,model.getSeparator());
    Hierarchy h=model.getInputConfig().getHierarchy(model.getSelectedAttribute());
    if (h == null) {
      main.showInfoDialog(main.getShell(),Resources.getMessage("String_Node_Str"),Resources.getMessage("String_Node_Str"));
    }
 else {
      out.write(h.getHierarchy());
    }
  }
 catch (  final Exception e) {
    main.showErrorDialog(main.getShell(),Resources.getMessage("String_Node_Str"),e);
  }
}

Fixed version (ground truth):
/** 
 * File->Export hierarchy
 */
public void actionMenuFileExportHierarchy(){
  if (model == null) {
    main.showInfoDialog(main.getShell(),Resources.getMessage("String_Node_Str"),Resources.getMessage("String_Node_Str"));
    return;
  }
  Hierarchy hierarchy=model.getInputConfig().getHierarchy(model.getSelectedAttribute());
  if (hierarchy == null || hierarchy.getHierarchy() == null || hierarchy.getHierarchy().length == 0 || hierarchy.getHierarchy()[0].length == 0) {
    main.showInfoDialog(main.getShell(),Resources.getMessage("String_Node_Str"),Resources.getMessage("String_Node_Str"));
    return;
  }
  String file=main.showSaveFileDialog(main.getShell(),"String_Node_Str");
  if (file == null) {
    return;
  }
  if (!file.endsWith("String_Node_Str")) {
    file=file + "String_Node_Str";
  }
  try {
    final CSVDataOutput out=new CSVDataOutput(file,model.getSeparator());
    out.write(hierarchy.getHierarchy());
  }
 catch (  final Exception e) {
    main.showErrorDialog(main.getShell(),Resources.getMessage("String_Node_Str"),e);
  }
}