How to use

CollectionHelper

in

org.n52.sos.util

public boolean isSetContent() {
  return CollectionHelper.isNotEmpty(content);
}

  protected String checkSoapAction(String soapAction, List<SoapHeader> soapHeaders) {
    if (soapAction != null && !soapAction.isEmpty()) {
      return soapAction;
    } else if (CollectionHelper.isEmpty(soapHeaders)) {
      for (SoapHeader soapHeader : soapHeaders) {
        if (WsaConstants.NS_WSA.equals(soapHeader.getNamespace()) && soapHeader instanceof WsaActionHeader) {
          return ((WsaActionHeader)soapHeader).getValue();
        }
      }
    }
    return null;
  }
}

private void parseComment(ObservationProcessType opt, ObservationProcess observationProcess) {
  if (CollectionHelper.isNotNullOrEmpty(opt.getCommentArray())) {
    observationProcess.setComments(Lists.newArrayList(opt.getCommentArray()));
  }
}

@SuppressWarnings({ "unchecked", "rawtypes" })
private SweAllowedTokens parseAllowedTokens(AllowedTokens att) {
  SweAllowedTokens allowedTokens = new SweAllowedTokens();
  if (att.isSetId()) {
    allowedTokens.setGmlId(att.getId());
  }
  if (CollectionHelper.isNotNullOrEmpty(att.getValueListArray())) {
    for (List list : att.getValueListArray()) {
      if (CollectionHelper.isNotEmpty(list)) {
        allowedTokens.setValue(list);
      }
    }
  }
  return allowedTokens;
}

addParentChildRestriction(c);
if (isEmpty(featureIdentifiers)) {
  return null; // because no features where found regarding the
} else if (isNotEmpty(featureIdentifiers)) {
  c.createCriteria(AbstractLegacyObservation.FEATURE_OF_INTEREST).add(
      Restrictions.in(FeatureOfInterest.IDENTIFIER, featureIdentifiers));

@Override
public void updateCacheOfferings(WritableContentCache cache, Collection<String> offeringsNeedingUpdate)
    throws OwsExceptionReport {
  checkCacheNotNull(cache);
  if (CollectionHelper.isEmpty(offeringsNeedingUpdate)) {
    return;
  }
  List<OwsExceptionReport> errors = CollectionHelper.synchronizedList();
  Session session = getSession();
  OfferingCacheUpdate update = new OfferingCacheUpdate(getCacheThreadCount(), offeringsNeedingUpdate);
  update.setCache(cache);
  update.setErrors(errors);
  update.setSession(session);
  
  LOGGER.info("Starting offering cache update for {} offering(s)", offeringsNeedingUpdate.size());
  long cacheUpdateStartTime = System.currentTimeMillis();
  try {
    update.execute();
  } catch (Exception e) {
    LOGGER.error("Error while updating ContentCache!", e);
    errors.add(new NoApplicableCodeException().causedBy(e).withMessage("Error while updating ContentCache!"));
  } finally {
    returnSession(session);
  }
  logCacheLoadTime(cacheUpdateStartTime);
  if (!errors.isEmpty()) {
    throw new CompositeOwsException(errors);
  }
}

@SuppressWarnings("unchecked")
@Override
public Set<EncoderKey> getEncoderKeyType() {
  return Collections.unmodifiableSet(CollectionHelper.union(ENCODER_KEY_TYPES, super.getEncoderKeyType()));
}

private void addAbstractPhysicalProcessValues(final AbstractPhysicalProcessType appt,
    final AbstractPhysicalProcess absPhysicalProcess) throws OwsExceptionReport {
  // set attachedTo
  if (absPhysicalProcess.isSetAttachedTo()) {
    if (appt.isSetAttachedTo()) {
      substitute(appt.getAttachedTo(), encodeObjectToXmlGml32(absPhysicalProcess.getAttachedTo()));
    } else {
      substitute(appt.addNewAttachedTo(), encodeObjectToXmlGml32(absPhysicalProcess.getAttachedTo()));
    }
  }
  // set localReferenceFrame
  // set localTimeFrame
  // set position
  if (CollectionHelper.isNullOrEmpty(appt.getPositionArray()) && absPhysicalProcess.isSetPosition()) {
    createPosition(appt.addNewPosition(), absPhysicalProcess.getPosition());
  }
  // set timePosition
  // // set location
  // if (absPhysicalProcess.isSetLocation()) {
  // appt.setSmlLocation(createLocation(absPhysicalProcess.getLocation()));
  // }
}

@SuppressWarnings({ "unchecked", "rawtypes" })
private SweAllowedValues parseAllowedValues(AllowedValues avt) {
  SweAllowedValues allowedValues = new SweAllowedValues();
  if (avt.isSetId()) {
    allowedValues.setGmlId(avt.getId());
  }
  if (CollectionHelper.isNotNullOrEmpty(avt.getValueListArray())) {
    for (List list : avt.getValueListArray()) {
      if (CollectionHelper.isNotEmpty(list)) {
        for (Object value : list) {
          allowedValues.addValue(Double.parseDouble(value.toString()));
        }
      }
    }
  }
  if (CollectionHelper.isNotNullOrEmpty(avt.getIntervalArray())) {
    for (List interval : avt.getIntervalArray()) {
      RangeValue<Double> rangeValue = new RangeValue<Double>();
      Iterator<Double> iterator = interval.iterator();
      if (iterator.hasNext()) {
        rangeValue.setRangeStart(iterator.next());
      }
      if (iterator.hasNext()) {
        rangeValue.setRangeEnd(iterator.next());
      }
      allowedValues.addInterval(rangeValue);
    }
  }
  return allowedValues;
}

@SuppressWarnings("unchecked")
private static Set<EncoderKey> createEncoderKeys() {
  return CollectionHelper.union(getDefaultEncoderKeys(), CodingHelper.encoderKeysForElements(
      WaterMLConstants.NS_WML_20_DR, GetObservationResponse.class, OmObservation.class,
      AbstractFeature.class, SingleObservationValue.class, MultiObservationValues.class));
}

if (describedObject.isSetName() && CollectionHelper.isNullOrEmpty(dot.getNameArray())) {
  if (CollectionHelper.isNullOrEmpty(dot.getKeywordsArray())) {
    final List<String> keywords = describedObject.getKeywords();
if (describedObject.isSetValidTime() && CollectionHelper.isNullOrEmpty(dot.getValidTimeArray())) {
  final Time time = describedObject.getValidTime();
  final XmlObject xbtime = encodeObjectToXmlGml32(time);
  if (CollectionHelper.isNullOrEmpty(dot.getCharacteristicsArray())) {
    dot.setCharacteristicsArray(createCharacteristics(describedObject.getCharacteristics()));
  if (CollectionHelper.isNullOrEmpty(dot.getContactsArray())) {
    ContactListType cl = ContactListType.Factory.newInstance();
    for (SmlContact contact : describedObject.getContact()) {
  if (CollectionHelper.isNullOrEmpty(dot.getDocumentationArray())) {
    dot.setDocumentationArray(createDocumentationArray(describedObject.getDocumentation()));

private boolean checkOfferingValues(final Collection<String> procedures, final SosEnvelope envelopeForOffering, final Set<String> featuresForOffering,
    final Collection<String> responseFormats) {
  return CollectionHelper.isNotEmpty(procedures) && SosEnvelope.isNotNullOrEmpty(envelopeForOffering) && CollectionHelper.isNotEmpty(featuresForOffering)
      && CollectionHelper.isNotEmpty(responseFormats) && CollectionHelper.isNotEmpty(procedures);
}

@SuppressWarnings({ "unchecked", "rawtypes" })
private SweAllowedTimes parseAllowedTimes(AllowedTimes att) throws DateTimeParseException {
  SweAllowedTimes allowedTimes = new SweAllowedTimes();
  if (att.isSetId()) {
    allowedTimes.setGmlId(att.getId());
  }
  if (CollectionHelper.isNotNullOrEmpty(att.getValueListArray())) {
    for (List list : att.getValueListArray()) {
      if (CollectionHelper.isNotEmpty(list)) {
        for (Object value : list) {
          allowedTimes.addValue(DateTimeHelper.parseIsoString2DateTime(value.toString()));
        }
      }
    }
  }
  if (CollectionHelper.isNotNullOrEmpty(att.getIntervalArray())) {
    for (List interval : att.getIntervalArray()) {
      RangeValue<DateTime> rangeValue = new RangeValue<DateTime>();
      Iterator iterator = interval.iterator();
      if (iterator.hasNext()) {
        rangeValue.setRangeStart(DateTimeHelper.parseIsoString2DateTime(iterator.next().toString()));
      }
      if (iterator.hasNext()) {
        rangeValue.setRangeEnd(DateTimeHelper.parseIsoString2DateTime(iterator.next().toString()));
      }
      allowedTimes.addInterval(rangeValue);
    }
  }
  return allowedTimes;
}

public List<GeographicalName> getAdminUnits() {
  if (CollectionHelper.isEmpty(adminUnits)) {
    addAdminUnit(new GeographicalName());
  }
  return Collections.unmodifiableList(adminUnits);
}

private void clearAbstracts(ServiceIdentification serviceIdent) {
  if (CollectionHelper.isNotNullOrEmpty(serviceIdent.getAbstractArray())) {
    for (int i = 0; i < serviceIdent.getAbstractArray().length; i++) {
      serviceIdent.removeAbstract(i);
    }
  }
}

@SuppressWarnings("unchecked")
private static Set<EncoderKey> createEncoderKeys() {
  return CollectionHelper.union(getDefaultEncoderKeys(),
      CodingHelper.encoderKeysForElements(WaterMLConstants.NS_WML_20, GetObservationResponse.class,
          OmObservation.class, SingleObservationValue.class, MultiObservationValues.class));
}

  abstractProcess.addNewDescription().setStringValue(sosAbstractProcess.getDescription());
if (sosAbstractProcess.isSetName() && CollectionHelper.isNullOrEmpty(abstractProcess.getNameArray())) {
if (sosAbstractProcess.isSetDocumentation() && CollectionHelper.isNullOrEmpty(abstractProcess.getDocumentationArray())) {
  abstractProcess.setDocumentationArray(createDocumentationArray(sosAbstractProcess.getDocumentation()));
if (sosAbstractProcess.isSetContact() && CollectionHelper.isNullOrEmpty(abstractProcess.getContactArray())) {
  ContactList contactList = createContactList(sosAbstractProcess.getContact());
  if (contactList != null && contactList.getMemberArray().length > 0) {

/**
 * Check the queried {@link AbstractValuedLegacyObservation}s for null and
 * set them as iterator to local variable.
 *
 * @param valuesResult
 *            Queried {@link AbstractValuedLegacyObservation}s
 */
private void setObservationValuesResult(Collection<ValuedObservation<?>> valuesResult) {
  if (CollectionHelper.isNotEmpty(valuesResult)) {
    this.valuesResult = valuesResult.iterator();
  }
}

public List<Spelling> getSpelling() {
  if (CollectionHelper.isEmpty(spelling)) {
    addSpelling(new Spelling());
  }
  return Collections.unmodifiableList(spelling);
}

private void parseInput(ObservationProcessType opt, ObservationProcess observationProcess) {
  if (CollectionHelper.isNotNullOrEmpty(opt.getInputArray())) {
    parseReferenceType(opt.getInputArray());
  }
}