@Override public void removeObservablePropertyForResultTemplate(String resultTemplate, String observableProperty) { CacheValidation.notNullOrEmpty(RESULT_TEMPLATE, resultTemplate); CacheValidation.notNullOrEmpty(OBSERVABLE_PROPERTY, observableProperty); LOG.trace("Removing observableProperty {} from resultTemplate {}", observableProperty, resultTemplate); this.observedPropertiesForResultTemplates.getOrDefault(resultTemplate, Collections.emptySet()) .remove(observableProperty); }
@Override public void removeProcedureForObservableProperty(String observableProperty, String procedure) { CacheValidation.notNullOrEmpty(OBSERVABLE_PROPERTY, observableProperty); CacheValidation.notNullOrEmpty(PROCEDURE, procedure); LOG.trace("Removing procedure {} from observableProperty {}", procedure, observableProperty); this.proceduresForObservableProperties.getOrDefault(observableProperty, Collections.emptySet()) .remove(procedure); }
@Override public void removeProceduresForFeatureOfInterest(String featureOfInterest) { CacheValidation.notNullOrEmpty(FEATURE_OF_INTEREST, featureOfInterest); LOG.trace("Removing procedures for featureOfInterest {}", featureOfInterest); this.proceduresForFeaturesOfInterest.remove(featureOfInterest); }
@Override public void removeProceduresForOffering(String offering) { CacheValidation.notNullOrEmpty(OFFERING, offering); LOG.trace("Removing procedures for offering {}", offering); this.proceduresForOfferings.remove(offering); }
@Override public void removeResultTemplateForOffering(String offering, String resultTemplate) { CacheValidation.notNullOrEmpty(OFFERING, offering); CacheValidation.notNullOrEmpty(RESULT_TEMPLATE, resultTemplate); LOG.trace("Removing resultTemplate {} from offering {}", resultTemplate, offering); this.resultTemplatesForOfferings.getOrDefault(offering, Collections.emptySet()).remove(resultTemplate); }
@Override public void removeResultTemplatesForOffering(String offering) { CacheValidation.notNullOrEmpty(OFFERING, offering); LOG.trace("Removing ResultTemplates for offering {}", offering); this.resultTemplatesForOfferings.remove(offering); }
@Override public void removeRoleForRelatedFeature(String relatedFeature, String role) { CacheValidation.notNullOrEmpty(RELATED_FEATURE, relatedFeature); CacheValidation.notNullOrEmpty(ROLE, role); LOG.trace("Removing role {} from relatedFeature {}", role, relatedFeature); this.rolesForRelatedFeatures.getOrDefault(relatedFeature, Collections.emptySet()).remove(role); }
@Override public void removeHiddenChildProcedureForOffering(String offering, String procedure) { CacheValidation.notNullOrEmpty(OFFERING, offering); CacheValidation.notNullOrEmpty(PROCEDURE, procedure); LOG.trace("Removing hidden chil procedure {} from offering {}", procedure, offering); this.hiddenChildProceduresForOfferings.getOrDefault(offering, Collections.emptySet()).remove(procedure); }
@Override public void removeFeatureOfInterestTypeForOffering(String offering, String featureOfInterestType) { CacheValidation.notNullOrEmpty(OFFERING, offering); CacheValidation.notNullOrEmpty(FEATURE_OF_INTEREST_TYPE, featureOfInterestType); LOG.trace("Removing observationType {} from offering {}", featureOfInterestType, offering); this.featureOfInterestTypesForOfferings.getOrDefault(offering, Collections.emptySet()) .remove(featureOfInterestType); }
@Override public void addPublishedOffering(String offering) { CacheValidation.notNullOrEmpty(PUBLISHED_OFFERING, offering); LOG.trace("Adding published offering {}", offering); publishedOffering.add(offering); }
@Override public void removePublishedOffering(String offering) { CacheValidation.notNullOrEmpty(PUBLISHED_OFFERING, offering); LOG.trace("Removing published offering {}", offering); publishedOffering.remove(offering); }
@Override public void addObservablePropertyForProcedure(String procedure, String observableProperty) { CacheValidation.notNullOrEmpty(PROCEDURE, procedure); CacheValidation.notNullOrEmpty(OBSERVABLE_PROPERTY, observableProperty); LOG.trace("Adding observableProperty {} to procedure {}", observableProperty, procedure); this.observablePropertiesForProcedures.computeIfAbsent(procedure, createSynchronizedSet()) .add(observableProperty); }
@Override public void setObservablePropertiesForResultTemplate(String resultTemplate, Collection<String> observableProperties) { CacheValidation.notNullOrEmpty(RESULT_TEMPLATE, resultTemplate); final Set<String> newValue = newSynchronizedSet(observableProperties); LOG.trace("Setting observableProperties for resultTemplate {} to {}", resultTemplate, newValue); this.observedPropertiesForResultTemplates.put(resultTemplate, newValue); }
@Override public void addParentFeature(String featureOfInterest, String parentFeature) { CacheValidation.notNullOrEmpty(FEATURE_OF_INTEREST, featureOfInterest); CacheValidation.notNullOrEmpty(PARENT_FEATURE, parentFeature); LOG.trace("Adding parentFeature {} to featureOfInterest {}", parentFeature, featureOfInterest); this.parentFeaturesForFeaturesOfInterest.computeIfAbsent(featureOfInterest, createSynchronizedSet()) .add(parentFeature); this.childFeaturesForFeatureOfInterest.computeIfAbsent(parentFeature, createSynchronizedSet()) .add(featureOfInterest); }
@Override public void setMinResultTimeForOffering(String offering, DateTime minTime) { CacheValidation.notNullOrEmpty(OFFERING, offering); LOG.trace("Setting minimal ResultTime for Offering {} to {}", offering, minTime); if (minTime == null) { this.minResultTimeForOfferings.remove(offering); } else { this.minResultTimeForOfferings.put(offering, DateTimeHelper.toUTC(minTime)); } }
@Override public void removeFeatureOfInterestHumanReadableNameForIdentifier(String identifier) { CacheValidation.notNullOrEmpty(FEATURE_OF_INTEREST, identifier); LOG.trace("Removing featuresOfInterest human readable name for identifier {}", identifier); featureOfInterestIdentifierHumanReadableName.remove(identifier); }
@Override public void addObservablePropertyForCompositePhenomenon(String compositePhenomenon, String observableProperty) { CacheValidation.notNullOrEmpty(COMPOSITE_PHENOMENON, compositePhenomenon); CacheValidation.notNullOrEmpty(OBSERVABLE_PROPERTY, observableProperty); LOG.trace("Adding observable property {} to composite phenomenon {}", observableProperty, compositePhenomenon); this.observablePropertiesForCompositePhenomenons.computeIfAbsent(compositePhenomenon, createSynchronizedSet()) .add(observableProperty); addCompositePhenomenon(compositePhenomenon); }
@Override public void addTypeOfProcedure(String type, Set<String> instances) { CacheValidation.notNullOrEmpty(TYPE_PROCEDURE, type); CacheValidation.noNullValues(PROCEDURE_INSTANCES, instances); LOG.trace("Adding instances {} to type '{}'", instances, type); if (hasInstancesForProcedure(type)) { typeOfProceduresMap.get(type).addAll(instances); } else { typeOfProceduresMap.put(type, instances); } }
@Override public void addAllowedObservationTypesForOffering(String offering, Collection<String> allowedObservationTypes) { CacheValidation.notNullOrEmpty(OFFERING, offering); CacheValidation.noNullValues(ALLOWED_OBSERVATION_TYPES, allowedObservationTypes); LOG.trace("Adding AllowedObservationTypes {} to Offering {}", allowedObservationTypes, offering); this.allowedObservationTypeForOfferings.computeIfAbsent(offering, createSynchronizedSet()) .addAll(allowedObservationTypes); }
@Override public void addOfferingForFeaturesOfInterest(final String offering, final Collection<String> featuresOfInterest) { CacheValidation.notNullOrEmpty(OFFERING, offering); CacheValidation.noNullOrEmptyValues(FEATURES_OF_INTEREST, featuresOfInterest); LOG.trace("Adding offering {} to featureOfInterest {}", offering, featuresOfInterest); for (final String featureOfInterest : featuresOfInterest) { this.offeringsForFeaturesOfInterest.computeIfAbsent(featureOfInterest, createSynchronizedSet()) .add(offering); } }