private DatasetField copy(Object version, DatasetFieldCompoundValue parent) {
    DatasetField dsf = new DatasetField();
    dsf.setDatasetFieldType(datasetFieldType);

    if (version != null) {
      if (version.getClass().getName().equals("edu.harvard.iq.dataverse.DatasetVersion")) {
        dsf.setDatasetVersion((DatasetVersion) version);
      } else {
        dsf.setTemplate((Template) version);
      }
    }

    dsf.setParentDatasetFieldCompoundValue(parent);
    dsf.setControlledVocabularyValues(controlledVocabularyValues);

    for (DatasetFieldValue dsfv : datasetFieldValues) {
      dsf.getDatasetFieldValues().add(dsfv.copy(dsf));
    }

    for (DatasetFieldCompoundValue compoundValue : datasetFieldCompoundValues) {
      dsf.getDatasetFieldCompoundValues().add(compoundValue.copy(dsf));
    }

    return dsf;
  }
 public String getCompoundDisplayValue() {
   String returnString = "";
   for (DatasetFieldCompoundValue dscv : datasetFieldCompoundValues) {
     for (DatasetField dsf : dscv.getChildDatasetFields()) {
       for (String value : dsf.getValues()) {
         if (!(value == null)) {
           returnString += (returnString.equals("") ? "" : "; ") + value.trim();
         }
       }
     }
   }
   return returnString;
 }
  public void setValueDisplayOrder() {
    if (this.getDatasetFieldType().isPrimitive()
        && !this.getDatasetFieldType().isControlledVocabulary()) {
      for (int i = 0; i < datasetFieldValues.size(); i++) {
        datasetFieldValues.get(i).setDisplayOrder(i);
      }

    } else if (this.getDatasetFieldType().isCompound()) {
      for (int i = 0; i < datasetFieldCompoundValues.size(); i++) {
        DatasetFieldCompoundValue compoundValue = datasetFieldCompoundValues.get(i);
        compoundValue.setDisplayOrder(i);
        for (DatasetField dsf : compoundValue.getChildDatasetFields()) {
          dsf.setValueDisplayOrder();
        }
      }
    }
  }
  private boolean isEmpty(boolean forDisplay) {
    if (datasetFieldType.isPrimitive()) { // primitive
      for (String value : getValues()) {
        if (!StringUtils.isBlank(value) && !(forDisplay && DatasetField.NA_VALUE.equals(value))) {
          return false;
        }
      }
    } else { // compound
      for (DatasetFieldCompoundValue cv : datasetFieldCompoundValues) {
        for (DatasetField subField : cv.getChildDatasetFields()) {
          if (!subField.isEmpty(forDisplay)) {
            return false;
          }
        }
      }
    }

    return true;
  }
 public Dataverse getDataverse() {
   if (datasetVersion != null) {
     return datasetVersion.getDataset().getOwner();
   } else if (parentDatasetFieldCompoundValue != null) {
     return parentDatasetFieldCompoundValue.getParentDatasetField().getDataverse();
   } else if (template != null) {
     return template.getDataverse();
   } else {
     throw new IllegalStateException(
         "DatasetField is in an illegal state: no dataset version, compound value, or template is set as its parent.");
   }
 }
 public boolean removeBlankDatasetFieldValues() {
   if (this.getDatasetFieldType().isPrimitive()) {
     if (!this.getDatasetFieldType().isControlledVocabulary()) {
       Iterator<DatasetFieldValue> dsfvIt = this.getDatasetFieldValues().iterator();
       while (dsfvIt.hasNext()) {
         DatasetFieldValue dsfv = dsfvIt.next();
         if (StringUtils.isBlank(dsfv.getValue())) {
           dsfvIt.remove();
         }
       }
       if (this.getDatasetFieldValues().isEmpty()) {
         return true;
       }
     } else { // controlled vocab
       if (this.getControlledVocabularyValues().isEmpty()) {
         return true;
       }
     }
   } else if (this.getDatasetFieldType().isCompound()) {
     Iterator<DatasetFieldCompoundValue> cvIt = this.getDatasetFieldCompoundValues().iterator();
     while (cvIt.hasNext()) {
       DatasetFieldCompoundValue cv = cvIt.next();
       Iterator<DatasetField> dsfIt = cv.getChildDatasetFields().iterator();
       while (dsfIt.hasNext()) {
         if (dsfIt.next().removeBlankDatasetFieldValues()) {
           dsfIt.remove();
         }
       }
       if (cv.getChildDatasetFields().isEmpty()) {
         cvIt.remove();
       }
     }
     if (this.getDatasetFieldCompoundValues().isEmpty()) {
       return true;
     }
   }
   return false;
 }
  private static DatasetField createNewEmptyDatasetField(DatasetFieldType dsfType) {
    DatasetField dsfv = new DatasetField();
    dsfv.setDatasetFieldType(dsfType);

    if (dsfType.isPrimitive()) {
      if (!dsfType.isControlledVocabulary()) {
        dsfv.getDatasetFieldValues().add(new DatasetFieldValue(dsfv));
      }
    } else { // compound field
      dsfv.getDatasetFieldCompoundValues()
          .add(DatasetFieldCompoundValue.createNewEmptyDatasetFieldCompoundValue(dsfv));
    }

    return dsfv;
  }
 public void addDatasetFieldCompoundValue(int index) {
   datasetFieldCompoundValues.add(
       index, DatasetFieldCompoundValue.createNewEmptyDatasetFieldCompoundValue(this));
 }