org.n52.sos.util.CollectionHelper java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Point p =new Point(x, y)
new Point()
MouseEvent e;e.getPoint()
Smart code suggestions by Tabnine
}

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());
  }
}

Most used methods

Popular in Java

Running tasks concurrently on multiple threads
onCreateOptionsMenu (Activity)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
scheduleAtFixedRate (ScheduledExecutorService)
ResourceBundle (java.util)
ResourceBundle is an abstract class which is the superclass of classes which provide Locale-specifi
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
Stream (java.util.stream)
A sequence of elements supporting sequential and parallel aggregate operations. The following exampl
Reference (javax.naming)
JOptionPane (javax.swing)
Join (org.hibernate.mapping)

How to useCollectionHelper in org.n52.sos.util

Best Java code snippets using org.n52.sos.util.CollectionHelper (Showing top 20 results out of 315)

How to use
CollectionHelper
in
org.n52.sos.util