Event.java
/*
* Event
*/
package gov.usgs.earthquake.indexer;
import gov.usgs.earthquake.product.ProductId;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* An event is a group of products that are nearby in space and time.
*
* Which products appear in an event depend primarily on the
* ProductIndexQuery.ResultType that is used when retrieving an event from the
* index. Unless CURRENT is used, you may not get what you expect.
*/
public class Event implements Comparable<Event> {
/** Origin product type */
public static final String ORIGIN_PRODUCT_TYPE = "origin";
/** Associate product type */
public static final String ASSOCIATE_PRODUCT_TYPE = "associate";
/** Disassociate product type */
public static final String DISASSOCIATE_PRODUCT_TYPE = "disassociate";
/** Property for othereventsource */
public static final String OTHEREVENTSOURCE_PROPERTY = "othereventsource";
/** Property for othereventsourcecode */
public static final String OTHEREVENTSOURCECODE_PROPERTY = "othereventsourcecode";
/** An ID used by the ProductIndex. */
private Long indexId = null;
/** Products nearby in space and time. Keyed by type. */
private Map<String, List<ProductSummary>> products = new HashMap<String, List<ProductSummary>>();
/** Cached summary. */
private EventSummary eventSummary = null;
/**
* Default constructor.
*
* All fields are set to null, and the list of products is empty.
*/
public Event() {
}
/**
* Construct an event with only an indexId. The products map will be empty.
*
* @param indexId the indexId to set.
*/
public Event(final Long indexId) {
this.setIndexId(indexId);
}
/**
* Construct and event with an indexId and a list of products.
*
* @param indexId the product index id.
* @param products the list of products.
*/
public Event(final Long indexId, final Map<String, List<ProductSummary>> products) {
this.setIndexId(indexId);
this.setProducts(products);
}
/**
* Copy constructor for event.
*
* The products associated with this event are not cloned, but the list of
* products is.
*
* @param copy the event to clone.
*/
public Event(final Event copy) {
this(copy.getIndexId(), copy.getAllProducts());
}
/**
* Get the index id.
*
* @return the indexId or null if one hasn't been assigned.
*/
public Long getIndexId() {
return indexId;
}
/**
* Set the index id.
*
* @param indexId the indexId to set.
*/
public void setIndexId(Long indexId) {
this.indexId = indexId;
}
/**
* Get all products associated with event, even if they are deleted.
*
* @return all products associated with event.
*/
public Map<String, List<ProductSummary>> getAllProducts() {
return products;
}
/**
* Get the event products.
*
* Only returns products that have not been deleted or superseded. This method
* returns a copy of the underlying product map that has been filtered to remove
* deleted products.
*
* @return a map of event products.
* @see #getAllProducts()
*/
public Map<String, List<ProductSummary>> getProducts() {
Map<String, List<ProductSummary>> notDeleted = new HashMap<String, List<ProductSummary>>();
Iterator<String> types = products.keySet().iterator();
while (types.hasNext()) {
String type = types.next();
List<ProductSummary> notDeletedProducts = getProducts(type);
if (notDeletedProducts.size() > 0) {
notDeleted.put(type, notDeletedProducts);
}
}
return notDeleted;
}
/**
* Set products.
*
* ProductSummaries are not cloned, but lists are.
*
* @param newProducts the products to set.
*/
public void setProducts(final Map<String, List<ProductSummary>> newProducts) {
this.products.clear();
Iterator<String> iter = new TreeSet<String>(newProducts.keySet()).iterator();
while (iter.hasNext()) {
String type = iter.next();
this.products.put(type, new ArrayList<ProductSummary>(newProducts.get(type)));
}
eventSummary = null;
}
/**
* A convenience method for adding a product summary to an event object.
*
* Note: this method does not update any associated product index.
*
* @param summary the summary to add to this event.
*/
public void addProduct(final ProductSummary summary) {
String type = summary.getId().getType();
List<ProductSummary> list = products.get(type);
if (list == null) {
list = new ArrayList<ProductSummary>();
products.put(type, list);
}
if (!list.contains(summary)) {
list.add(summary);
}
eventSummary = null;
}
/**
* A convenience method for removing a product summary from an event object.
*
* Note: this method does not update any associated product index.
*
* @param summary the summary to remove from this event.
*/
public void removeProduct(final ProductSummary summary) {
String type = summary.getId().getType();
// find the list of products of this type
List<ProductSummary> list = products.get(type);
if (list != null) {
// remove the product from the list
list.remove(summary);
if (list.size() == 0) {
// if the list is now empty, remove the list
products.remove(type);
}
}
eventSummary = null;
}
/**
* Convenience method to get products of a given type.
*
* This method always returns a copy of the internal list, and may be empty.
* Only returns products that have not been deleted or superseded.
*
* @param type the product type.
* @return a list of products of that type, which may be empty.
*/
public List<ProductSummary> getProducts(final String type) {
ArrayList<ProductSummary> typeProducts = new ArrayList<ProductSummary>();
if (products.containsKey(type)) {
// only return products that haven't been deleted
typeProducts.addAll(getWithoutDeleted(getWithoutSuperseded(products.get(type))));
}
return typeProducts;
}
/**
* Get all event products (including those that are deleted or superseded).
*
* @return a list of event products.
*/
public List<ProductSummary> getAllProductList() {
List<ProductSummary> allProductList = new ArrayList<ProductSummary>();
Map<String, List<ProductSummary>> allProducts = getAllProducts();
Iterator<String> iter = allProducts.keySet().iterator();
while (iter.hasNext()) {
allProductList.addAll(allProducts.get(iter.next()));
}
return allProductList;
}
/**
* Get all event products that have not been deleted or superseded as a list.
*
* @return a list of event products.
*/
public List<ProductSummary> getProductList() {
List<ProductSummary> productList = new ArrayList<ProductSummary>();
Map<String, List<ProductSummary>> notDeletedProducts = getProducts();
Iterator<String> iter = notDeletedProducts.keySet().iterator();
while (iter.hasNext()) {
productList.addAll(notDeletedProducts.get(iter.next()));
}
return productList;
}
/**
* Get preferred products of all types.
*
* This map will contain one product of each type, chosen by preferred weight.
*
* @return a map from product type to the preferred product of that type.
*/
public Map<String, ProductSummary> getPreferredProducts() {
Map<String, ProductSummary> preferredProducts = new HashMap<String, ProductSummary>();
Map<String, List<ProductSummary>> notDeletedProducts = getProducts();
Iterator<String> types = notDeletedProducts.keySet().iterator();
while (types.hasNext()) {
String type = types.next();
preferredProducts.put(type, getPreferredProduct(notDeletedProducts.get(type)));
}
return preferredProducts;
}
/**
* Get the preferred product of a specific type.
*
* @param type type of product to get.
* @return most preferred product of that type, or null if no product of that
* type is associated.
*/
public ProductSummary getPreferredProduct(final String type) {
return getPreferredProduct(getProducts(type));
}
/**
* Get a map of all event ids associated with this event.
*
* Same as Event.getEventCodes(this.getAllProductList());
*
* @deprecated use {@link #getAllEventCodes(boolean)} instead.
* @return map of all event ids associated with this event.
*/
@Deprecated
public Map<String, String> getEventCodes() {
return getEventCodes(this.getAllProductList());
}
/**
* Get a map of all event ids associated with this event.
*
* Map key is eventSource, Map value is eventSourceCode.
*
* @deprecated use {@link #getAllEventCodes(boolean)} instead.
* @param summaries the summaries list to extract event codes from.
* @return map of all event ids associated with this event.
*/
@Deprecated
public static Map<String, String> getEventCodes(final List<ProductSummary> summaries) {
Map<String, String> eventIds = new HashMap<String, String>();
// order most preferred last,
// to minimize impact of multiple codes from same source
List<ProductSummary> sorted = getSortedMostPreferredFirst(getWithoutSuperseded(summaries));
Collections.reverse(sorted);
// done ordering
Iterator<ProductSummary> iter = sorted.iterator();
while (iter.hasNext()) {
ProductSummary product = iter.next();
String source = product.getEventSource();
String code = product.getEventSourceCode();
if (source != null && code != null) {
eventIds.put(source.toLowerCase(), code.toLowerCase());
}
}
return eventIds;
}
/**
* Get a map of all event ids associated with this event, recognizing that one
* source may have multiple codes (they broke the rules, but it happens).
*
* @param includeDeleted whether to include ids for sub events whose products
* have all been deleted.
* @return Map from source to a list of codes from that source.
*/
public Map<String, List<String>> getAllEventCodes(final boolean includeDeleted) {
Map<String, List<String>> allEventCodes = new HashMap<String, List<String>>();
Map<String, Event> subEvents = getSubEvents();
Iterator<String> iter = subEvents.keySet().iterator();
while (iter.hasNext()) {
Event subEvent = subEvents.get(iter.next());
if (!includeDeleted && subEvent.isDeleted()) {
// check for non-deleted products that should
// keep the event code alive
List<ProductSummary> nonDeletedProducts = getWithoutDeleted(getWithoutSuperseded(subEvent.getAllProductList()));
if (nonDeletedProducts.size() == 0) {
// filter deleted events
continue;
}
// otherwise, event has active products;
// prevent same source associations
}
// add code to list for source
String source = subEvent.getSource();
String sourceCode = subEvent.getSourceCode();
List<String> sourceEventCodes = allEventCodes.get(source);
if (sourceEventCodes == null) {
// create list for source
sourceEventCodes = new ArrayList<String>();
allEventCodes.put(source, sourceEventCodes);
}
// keep list distinct
if (!sourceEventCodes.contains(sourceCode)) {
sourceEventCodes.add(sourceCode);
}
}
return allEventCodes;
}
/**
* Get a list of all the preferred products sorted based on their authoritative
* weights
*
* @return sorted list of ProductSummary objects
*/
public List<ProductSummary> getPreferredProductsSorted() {
Map<String, ProductSummary> preferred = getPreferredProducts();
// Transform the preferred HashMap into a List so we can sort based on
// preferred weight
List<ProductSummary> productList = new ArrayList<ProductSummary>(preferred.values());
// Sort the list, then iterate through it until we find the specified
// property
Collections.sort(productList, new MostPreferredFirstComparator());
return productList;
}
/**
* Get the event id.
*
* The event id is the combination of event source and event source code.
*
* @return the event id, or null if either event source or event source code is
* null.
* @see #getSource()
* @see #getSourceCode()
*/
public String getEventId() {
ProductSummary product = getEventIdProduct();
if (product != null) {
return product.getEventId();
}
return null;
}
/**
* Get the preferred source for this event. If an origin product exists, it's
* value is used.
*
* @return Source from preferred product or null
*/
public String getSource() {
ProductSummary product = getEventIdProduct();
if (product != null) {
return product.getEventSource();
}
return null;
}
/**
* Get the preferred source code for this event. If an origin product exists,
* it's value is used.
*
* @return Source code from preferred product or null
*/
public String getSourceCode() {
ProductSummary product = getEventIdProduct();
if (product != null) {
return product.getEventSourceCode();
}
return null;
}
/**
* Get the product used for eventsource and eventsourcecode.
*
* Event ID comes from the preferred origin product.
*
* @return The most preferred product summary. This summary is used to determine
* the eventsouce and eventsourcecode.
* @see #getPreferredOriginProduct()
*/
protected ProductSummary getEventIdProduct() {
ProductSummary product = getPreferredOriginProduct();
if (product == null) {
product = getProductWithOriginProperties();
}
return product;
}
/**
* Get the most recent product with origin properties (id, lat, lon, time).
*
* <strong>NOTE</strong>: this product may have been superseded by a delete.
* When an event has not been deleted, this method should be consistent with
* {@link #getPreferredOriginProduct()}.
*
* Products are checked in the following order, sorted most preferred first
* within each group. The first matching product is returned:
* <ol>
* <li>"origin" products not superseded or deleted, that have origin
* properties</li>
* <li>"origin" products superseded by a delete, that have origin
* properties</li>
* <li>products not superseded or deleted, that have origin properties</li>
* <li>products superseded by a delete, that have origin properties</li>
* </ol>
*
* @return the most recent product with origin properties.
* @see #productHasOriginProperties(ProductSummary)
*/
public ProductSummary getProductWithOriginProperties() {
Map<String, List<ProductSummary>> allProducts = getAllProducts();
List<ProductSummary> productsList = null;
ProductSummary preferredProduct = null;
Iterator<ProductSummary> iter = null;
productsList = allProducts.get(ORIGIN_PRODUCT_TYPE);
if (productsList != null) {
// "origin" products not superseded or deleted
productsList = getSortedMostPreferredFirst(
getWithoutDeleted(getWithoutSuperseded(allProducts.get(ORIGIN_PRODUCT_TYPE))));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (productHasOriginProperties(preferredProduct)) {
return preferredProduct;
}
}
// "origin" products superseded by a delete
productsList = getSortedMostPreferredFirst(
getWithoutSuperseded(getWithoutDeleted(allProducts.get(ORIGIN_PRODUCT_TYPE))));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (productHasOriginProperties(preferredProduct)) {
return preferredProduct;
}
}
}
// products not superseded or deleted
productsList = getSortedMostPreferredFirst(
getWithoutDeleted(getWithoutSuperseded(productTypeMapToList(allProducts))));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (productHasOriginProperties(preferredProduct)) {
return preferredProduct;
}
}
// products superseded by a delete
productsList = getSortedMostPreferredFirst(
getWithoutSuperseded(getWithoutDeleted(productTypeMapToList(allProducts))));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (productHasOriginProperties(preferredProduct)) {
return preferredProduct;
}
}
return null;
}
/**
* Get the most preferred origin-like product for this event.
*
* The event is considered deleted if the returned product is null, deleted, or
* does not have origin properties. Information about the event may still be
* available using {@link #getProductWithOriginProperties()}.
*
* Products are checked in the following order, sorted most preferred first
* within each group. The first matching product is returned:
* <ul>
* <li>If any "origin" products exist:
* <ol>
* <li>"origin" products not superseded or deleted, that have origin
* properties.</li>
* <li>"origin" products not superseded, that have an event id.</li>
* </ol>
* </li>
* <li>If no "origin" products exist:
* <ol>
* <li>products not superseded or deleted, that have origin properties.</li>
* <li>products not superseded, that have an event id.</li>
* </ol>
* </li>
* </ul>
*
* @return the most recent product with origin properties.
* @see #productHasOriginProperties(ProductSummary)
*/
public ProductSummary getPreferredOriginProduct() {
Map<String, List<ProductSummary>> allProducts = getAllProducts();
List<ProductSummary> productsList = null;
ProductSummary preferredProduct = null;
Iterator<ProductSummary> iter = null;
productsList = allProducts.get(ORIGIN_PRODUCT_TYPE);
if (productsList != null) {
// "origin" products not superseded or deleted,
// that have origin properties
productsList = getSortedMostPreferredFirst(
getWithoutDeleted(getWithoutSuperseded(allProducts.get(ORIGIN_PRODUCT_TYPE))));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (productHasOriginProperties(preferredProduct)) {
return preferredProduct;
}
}
// "origin" products not superseded,
// that have event id
productsList = getSortedMostPreferredFirst(getWithoutSuperseded(allProducts.get(ORIGIN_PRODUCT_TYPE)));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (preferredProduct.getEventSource() != null && preferredProduct.getEventSourceCode() != null) {
return preferredProduct;
}
}
return null;
}
// products not superseded or deleted,
// that have origin properties
productsList = getSortedMostPreferredFirst(
getWithoutDeleted(getWithoutSuperseded(productTypeMapToList(allProducts))));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (productHasOriginProperties(preferredProduct)) {
return preferredProduct;
}
}
// products not superseded,
// that have event id
productsList = getSortedMostPreferredFirst(getWithoutSuperseded(productTypeMapToList(allProducts)));
iter = productsList.iterator();
while (iter.hasNext()) {
preferredProduct = iter.next();
if (preferredProduct.getEventSource() != null && preferredProduct.getEventSourceCode() != null) {
return preferredProduct;
}
}
return null;
}
/**
* Check if a product can define an event (id, lat, lon, time).
*
* @param product product to check.
* @return true if product has id, lat, lon, and time properties.
*/
public static boolean productHasOriginProperties(final ProductSummary product) {
return (product.getEventSource() != null && product.getEventSourceCode() != null
&& product.getEventLatitude() != null && product.getEventLongitude() != null && product.getEventTime() != null);
}
/**
* Get the most preferred magnitude product for event.
*
* Currently calls {@link #getPreferredOriginProduct()}.
*
* @return the most preferred magnitude product for event.
*/
public ProductSummary getPreferredMagnitudeProduct() {
return getPreferredOriginProduct();
}
/**
* Get the preferred time for this event. If an origin product exists, it's
* value is used.
*
* @return Time from preferred product or null
*/
public Date getTime() {
ProductSummary preferred = getProductWithOriginProperties();
if (preferred != null) {
return preferred.getEventTime();
}
return null;
}
/**
* Get the preferred latitude for this event. If an origin product exists, it's
* value is used.
*
* @return Latitude from preferred product or null
*/
public BigDecimal getLatitude() {
ProductSummary preferred = getProductWithOriginProperties();
if (preferred != null) {
return preferred.getEventLatitude();
}
return null;
}
/**
* Get the preferred longitude for this event. If an origin product exists, it's
* value is used.
*
* @return Longitude from preferred product or null
*/
public BigDecimal getLongitude() {
ProductSummary preferred = getProductWithOriginProperties();
if (preferred != null) {
return preferred.getEventLongitude();
}
return null;
}
/**
* Event update time is most recent product update time.
*
* @return the most recent product update time.
*/
public Date getUpdateTime() {
Date updateTime = null;
Date time = null;
Iterator<ProductSummary> iter = getAllProductList().iterator();
while (iter.hasNext()) {
time = iter.next().getId().getUpdateTime();
if (updateTime == null || time.after(updateTime)) {
time = updateTime;
}
}
return updateTime;
}
/**
* Get the preferred depth for this event. If an origin product exists, it's
* value is used.
*
* @return Depth from preferred product or null
*/
public BigDecimal getDepth() {
ProductSummary preferred = getProductWithOriginProperties();
if (preferred != null) {
return preferred.getEventDepth();
}
return null;
}
/**
* Get the preferred magntitude for this event. If an origin product exists,
* it's value is used.
*
* @return magnitude from preferred product or null
*/
public BigDecimal getMagnitude() {
ProductSummary preferred = getPreferredMagnitudeProduct();
if (preferred != null) {
return preferred.getEventMagnitude();
}
return null;
}
/**
* @return boolean if the preferred event is deleted
*/
public boolean isDeleted() {
ProductSummary preferred = getPreferredOriginProduct();
if (preferred != null && !preferred.isDeleted() && Event.productHasOriginProperties(preferred)) {
// have "origin" type product, that isn't deleted,
// and has origin properties
return false;
}
// otherwise, deleted
return true;
}
/**
* Get the most preferred product from a list of products.
*
* @param all a list of products containing only one type of product.
* @return the product with the highest preferred weight, and if tied the most
* recent update time wins.
*/
public static ProductSummary getPreferredProduct(final List<ProductSummary> all) {
ProductSummary preferred = null;
Iterator<ProductSummary> iter = all.iterator();
while (iter.hasNext()) {
ProductSummary summary = iter.next();
if (preferred == null) {
preferred = summary;
} else {
long summaryWeight = summary.getPreferredWeight();
long preferredWeight = preferred.getPreferredWeight();
if (summaryWeight > preferredWeight || (summaryWeight == preferredWeight
&& summary.getId().getUpdateTime().after(preferred.getId().getUpdateTime()))) {
preferred = summary;
}
}
}
return preferred;
}
/**
* Summarize this event into preferred values.
*
* NOTE: the event summary may include information from an origin product, even
* when the preferred origin for the event has been deleted. Use
* getPreferredOriginProduct() to check the preferred origin of the event.
*
* @return an event summary.
*/
public EventSummary getEventSummary() {
if (eventSummary != null) {
return eventSummary;
}
EventSummary summary = new EventSummary();
summary.setIndexId(this.getIndexId());
summary.setDeleted(this.isDeleted());
ProductSummary eventIdProduct = this.getEventIdProduct();
if (eventIdProduct != null) {
summary.setSource(eventIdProduct.getEventSource());
summary.setSourceCode(eventIdProduct.getEventSourceCode());
}
ProductSummary originProduct = this.getProductWithOriginProperties();
if (originProduct != null) {
summary.setLatitude(originProduct.getEventLatitude());
summary.setLongitude(originProduct.getEventLongitude());
summary.setTime(originProduct.getEventTime());
summary.setDepth(originProduct.getEventDepth());
}
ProductSummary magnitudeProduct = this.getPreferredMagnitudeProduct();
if (magnitudeProduct != null) {
summary.setMagnitude(magnitudeProduct.getEventMagnitude());
}
// we may be able to avoid implementing this here, since the mapping
// interface will be driven by the PHP product index.
summary.getEventCodes().putAll(this.getEventCodes());
// cache summary
eventSummary = summary;
return summary;
}
/**
* Comparison class that compares two ProductSummary objects based on their
* preferred weight and update time.
*
*/
static class MostPreferredFirstComparator implements Comparator<ProductSummary> {
@Override
public int compare(ProductSummary p1, ProductSummary p2) {
if (p1.getPreferredWeight() > p2.getPreferredWeight()) {
return -1;
} else if (p1.getPreferredWeight() < p2.getPreferredWeight()) {
return 1;
} else {
Date p1Update = p1.getUpdateTime();
Date p2Update = p2.getUpdateTime();
if (p1Update.after(p2Update)) {
return -1;
} else if (p2Update.after(p1Update)) {
return 1;
} else {
return 0;
}
}
}
}
@Override
public int compareTo(Event that) {
int r;
List<ProductSummary> thisProducts = this.getProductList();
List<ProductSummary> thatProducts = that.getProductList();
if ((r = (thatProducts.size() - thisProducts.size())) != 0) {
return r;
}
Iterator<ProductSummary> thisIter = thisProducts.iterator();
Iterator<ProductSummary> thatIter = thatProducts.iterator();
while (thisIter.hasNext() && thatIter.hasNext()) {
// just compare product ids for now
r = thisIter.next().getId().compareTo(thatIter.next().getId());
if (r != 0) {
return r;
}
}
return 0;
}
/**
* Find the most preferred product.
*
* If preferredType is not null, products of this type are favored over those
* not of this type.
*
* If preferredNotNullProperty is not null, products that have this property set
* are favored over those without this property set.
*
* @param products the list of products to search.
* @param preferredType the preferred product type, if available.
* @param preferredNotNullProperty the preferred property name, if available.
* @return The most preferred product summary of the given type.
*/
public static ProductSummary getMostPreferred(final List<ProductSummary> products, final String preferredType,
final String preferredNotNullProperty) {
ProductSummary mostPreferred = null;
Iterator<ProductSummary> iter = products.iterator();
while (iter.hasNext()) {
ProductSummary next = iter.next();
// ignore products that don't have the preferredNotNullProperty
if (preferredNotNullProperty != null && next.getProperties().get(preferredNotNullProperty) == null) {
continue;
}
if (mostPreferred == null) {
// first product is most preferred so far
mostPreferred = next;
continue;
}
if (preferredType != null) {
if (next.getType().equals(preferredType)) {
if (!mostPreferred.getType().equals(preferredType)) {
// prefer products of this type
mostPreferred = next;
}
} else if (mostPreferred.getType().equals(preferredType)) {
// already have preferred product of preferred type
continue;
}
}
if (next.getPreferredWeight() > mostPreferred.getPreferredWeight()) {
// higher preferred weight
mostPreferred = next;
} else if (next.getPreferredWeight() == mostPreferred.getPreferredWeight()
&& next.getUpdateTime().after(mostPreferred.getUpdateTime())) {
// same preferred weight, newer update
mostPreferred = next;
}
}
return mostPreferred;
}
/**
* Remove deleted products from the list.
*
* @param products list of products to filter.
* @return copy of the products list with deleted products removed.
*/
public static List<ProductSummary> getWithoutDeleted(final List<ProductSummary> products) {
List<ProductSummary> withoutDeleted = new ArrayList<ProductSummary>();
Iterator<ProductSummary> iter = products.iterator();
while (iter.hasNext()) {
ProductSummary next = iter.next();
if (!next.isDeleted()) {
withoutDeleted.add(next);
}
}
return withoutDeleted;
}
/**
* Remove deleted products from the list.
*
* @param products list of products to filter.
* @return copy of the products list with deleted products removed.
*/
public static List<ProductSummary> getWithEventId(final List<ProductSummary> products) {
List<ProductSummary> withEventId = new ArrayList<ProductSummary>();
Iterator<ProductSummary> iter = products.iterator();
while (iter.hasNext()) {
ProductSummary next = iter.next();
if (next.getEventId() != null) {
withEventId.add(next);
}
}
return withEventId;
}
/**
* Remove old versions of products from the list.
*
* @param products list of products to filter.
* @return a copy of the products list with products of the same
* source+type+code but with older updateTimes (superseded) removed.
*/
public static List<ProductSummary> getWithoutSuperseded(final List<ProductSummary> products) {
// place product into latest, keyed by source+type+code,
// keeping only most recent update for each key
Map<String, ProductSummary> latest = new HashMap<String, ProductSummary>();
Iterator<ProductSummary> iter = products.iterator();
while (iter.hasNext()) {
ProductSummary summary = iter.next();
ProductId id = summary.getId();
// key is combination of source, type, and code
// since none of these may contain ":", it is used as a delimiter to
// prevent collisions.
String key = new StringBuffer(id.getSource()).append(":").append(id.getType()).append(":").append(id.getCode())
.toString();
if (!latest.containsKey(key)) {
// first product
latest.put(key, summary);
} else {
// keep latest product
ProductSummary other = latest.get(key);
if (other.getId().getUpdateTime().before(id.getUpdateTime())) {
latest.put(key, summary);
}
}
}
// those that are in the latest map have not been superseded
return new ArrayList<ProductSummary>(latest.values());
}
/**
* Sort a list of products, most preferred first.
*
* @param products the list of products to sort.
* @return a copy of the list sorted with most preferred first.
*/
public static List<ProductSummary> getSortedMostPreferredFirst(final List<ProductSummary> products) {
List<ProductSummary> mostPreferredFirst = new ArrayList<ProductSummary>(products);
Collections.sort(mostPreferredFirst, new MostPreferredFirstComparator());
return mostPreferredFirst;
}
static List<ProductSummary> productTypeMapToList(final Map<String, List<ProductSummary>> products) {
List<ProductSummary> list = new ArrayList<ProductSummary>();
Iterator<String> iter = products.keySet().iterator();
while (iter.hasNext()) {
list.addAll(products.get(iter.next()));
}
return list;
}
static Map<String, List<ProductSummary>> productListToTypeMap(final List<ProductSummary> products) {
Map<String, List<ProductSummary>> typeMap = new HashMap<String, List<ProductSummary>>();
Iterator<ProductSummary> iter = products.iterator();
while (iter.hasNext()) {
ProductSummary product = iter.next();
List<ProductSummary> typeProducts = typeMap.get(product.getType());
if (typeProducts == null) {
typeProducts = new ArrayList<ProductSummary>();
typeMap.put(product.getType(), typeProducts);
}
typeProducts.add(product);
}
return typeMap;
}
/**
* Return a list of sub-events that make up this event.
*
* Event lines are drawn by eventid. Products that have no eventid are included
* with the sub event whose id is considered preferred.
*
* @return map from eventid to event object with products for that eventid.
*/
public Map<String, Event> getSubEvents() {
// Map of sub-events keyed by product "eventId"
Map<String, Event> subEvents = new HashMap<String, Event>();
// Map of events by source_type_code
Map<String, Event> productEvents = new HashMap<String, Event>();
// this is the event that will have products without event id...
String preferredEventId = this.getEventId();
Event preferredSubEvent = new Event();
// put a placeholder with no products into the map for this purpose.
subEvents.put(preferredEventId, preferredSubEvent);
// List of all products associated to the current event
List<ProductSummary> allProducts = this.getAllProductList();
// handle products with a current version
HashSet<ProductSummary> withoutSuperseded = new HashSet<ProductSummary>(getWithoutSuperseded(allProducts));
Iterator<ProductSummary> products = withoutSuperseded.iterator();
while (products.hasNext()) {
ProductSummary product = products.next();
Event subEvent = null;
String subEventId = product.getEventId();
if (subEventId == null) {
// maybe try to find another version of product with id?
subEvent = preferredSubEvent;
} else {
subEvent = subEvents.get(subEventId);
if (subEvent == null) {
// first product for this sub event
subEvent = new Event();
subEvents.put(subEventId, subEvent);
}
}
subEvent.addProduct(product);
ProductId id = product.getId();
String key = id.getSource() + "_" + id.getType() + "_" + id.getCode();
productEvents.put(key, subEvent);
}
// handle superseded products
HashSet<ProductSummary> superseded = new HashSet<ProductSummary>(allProducts);
superseded.removeAll(withoutSuperseded);
products = superseded.iterator();
while (products.hasNext()) {
ProductSummary next = products.next();
ProductId id = next.getId();
String key = id.getSource() + "_" + id.getType() + "_" + id.getCode();
Event subEvent = productEvents.get(key);
subEvent.addProduct(next);
}
return subEvents;
}
/**
* Check if this event has an associate product for another given Event.
*
* @param otherEvent the other event.
* @return true if there is an associate product, false otherwise.
*/
public boolean hasAssociateProduct(final Event otherEvent) {
if (otherEvent == null) {
// cannot have an association to a null event...
return false;
}
String otherEventSource = otherEvent.getSource();
String otherEventSourceCode = otherEvent.getSourceCode();
if (otherEventSource == null || otherEventSourceCode == null) {
// same without source+code
return false;
}
// search associate products
Iterator<ProductSummary> iter = getProducts(ASSOCIATE_PRODUCT_TYPE).iterator();
while (iter.hasNext()) {
ProductSummary associate = iter.next();
if (otherEventSource.equalsIgnoreCase(associate.getProperties().get(OTHEREVENTSOURCE_PROPERTY))
&& otherEventSourceCode.equalsIgnoreCase(associate.getProperties().get(OTHEREVENTSOURCECODE_PROPERTY))) {
// associated
return true;
}
}
return false;
}
/**
* Check if this event has an disassociate product for another given Event.
*
* @param otherEvent the other event.
* @return true if there is an disassociate product, false otherwise.
*/
public boolean hasDisassociateProduct(final Event otherEvent) {
if (otherEvent == null) {
// cannot have an disassociation to a null event...
return false;
}
String otherEventSource = otherEvent.getSource();
String otherEventSourceCode = otherEvent.getSourceCode();
if (otherEventSource == null || otherEventSourceCode == null) {
// same without source+code
return false;
}
// search disassociate products
Iterator<ProductSummary> iter = getProducts(DISASSOCIATE_PRODUCT_TYPE).iterator();
while (iter.hasNext()) {
ProductSummary associate = iter.next();
if (otherEventSource.equalsIgnoreCase(associate.getProperties().get(OTHEREVENTSOURCE_PROPERTY))
&& otherEventSourceCode.equalsIgnoreCase(associate.getProperties().get(OTHEREVENTSOURCECODE_PROPERTY))) {
// disassociated
return true;
}
}
return false;
}
/**
* Same as isAssociated(that, new DefaultAssociator());
*
* @param that an event to test
* @return boolean true if associated, false otherwise
*/
public boolean isAssociated(final Event that) {
return this.isAssociated(that, new DefaultAssociator());
}
/**
* Check if an event is associated to this event.
*
* Reasons events may be considered disassociated:
* <ol>
* <li>Share a common EVENTSOURCE with different EVENTSOURCECODE.</li>
* <li>Either has a disassociate product for the other.</li>
* <li>Preferred location in space and time is NOT nearby, and no other reason
* to associate.</li>
* </ol>
*
* Reasons events may be considered associated:
* <ol>
* <li>Share a common EVENTID</li>
* <li>Either has an associate product for the other.</li>
* <li>Their preferred location in space and time is nearby.</li>
* </ol>
*
* @param that candidate event to test.
* @param associator An associator to compare two events
* @return true if associated, false otherwise.
*/
public boolean isAssociated(final Event that, final Associator associator) {
return associator.eventsAssociated(this, that);
}
/**
* Depending on logger level, takes in summary data and appends to buffer
*
* @param logger logger object
*/
public void log(final Logger logger) {
if (logger.isLoggable(Level.FINE)) {
EventSummary summary = this.getEventSummary();
logger.fine(new StringBuffer("Event").append("indexid=").append(summary.getIndexId()).append(", eventid=")
.append(summary.getId()).append(", latitude=").append(summary.getLatitude()).append(", longitude=")
.append(summary.getLongitude()).append(", time=").append(summary.getTime()).append(", deleted=")
.append(summary.isDeleted()).toString());
if (logger.isLoggable(Level.FINER)) {
StringBuffer buf = new StringBuffer("Products in event");
List<ProductSummary> products = this.getAllProductList();
Iterator<ProductSummary> iter = products.iterator();
while (iter.hasNext()) {
ProductSummary next = iter.next();
buf.append("\n\tstatus=").append(next.getStatus()).append(", id=").append(next.getId().toString())
.append(", eventid=").append(next.getEventId()).append(", latitude=").append(next.getEventLatitude())
.append(", longitude=").append(next.getEventLongitude()).append(", time=").append(next.getEventTime());
}
logger.finer(buf.toString());
}
}
}
}