Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.hadoop.yarn.api.records.timeline; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; import org.apache.hadoop.classification.InterfaceAudience.Private; import org.apache.hadoop.classification.InterfaceAudience.Public; import org.apache.hadoop.classification.InterfaceStability.Evolving; import org.apache.hadoop.yarn.util.TimelineServiceHelper; /** * <p> * The class that contains the the meta information of some conceptual entity * and its related events. The entity can be an application, an application * attempt, a container or whatever the user-defined object. * </p> * * <p> * Primary filters will be used to index the entities in * <code>TimelineStore</code>, such that users should carefully choose the * information they want to store as the primary filters. The remaining can be * stored as other information. * </p> */ @XmlRootElement(name = "entity") @XmlAccessorType(XmlAccessType.NONE) @Public @Evolving public class TimelineEntity implements Comparable<TimelineEntity> { private String entityType; private String entityId; private Long startTime; private List<TimelineEvent> events = new ArrayList<TimelineEvent>(); private HashMap<String, Set<String>> relatedEntities = new HashMap<String, Set<String>>(); private HashMap<String, Set<Object>> primaryFilters = new HashMap<String, Set<Object>>(); private HashMap<String, Object> otherInfo = new HashMap<String, Object>(); private String domainId; public TimelineEntity() { } /** * Get the entity type * * @return the entity type */ @XmlElement(name = "entitytype") public String getEntityType() { return entityType; } /** * Set the entity type * * @param entityType * the entity type */ public void setEntityType(String entityType) { this.entityType = entityType; } /** * Get the entity Id * * @return the entity Id */ @XmlElement(name = "entity") public String getEntityId() { return entityId; } /** * Set the entity Id * * @param entityId * the entity Id */ public void setEntityId(String entityId) { this.entityId = entityId; } /** * Get the start time of the entity * * @return the start time of the entity */ @XmlElement(name = "starttime") public Long getStartTime() { return startTime; } /** * Set the start time of the entity * * @param startTime * the start time of the entity */ public void setStartTime(Long startTime) { this.startTime = startTime; } /** * Get a list of events related to the entity * * @return a list of events related to the entity */ @XmlElement(name = "events") public List<TimelineEvent> getEvents() { return events; } /** * Add a single event related to the entity to the existing event list * * @param event * a single event related to the entity */ public void addEvent(TimelineEvent event) { events.add(event); } /** * Add a list of events related to the entity to the existing event list * * @param events * a list of events related to the entity */ public void addEvents(List<TimelineEvent> events) { this.events.addAll(events); } /** * Set the event list to the given list of events related to the entity * * @param events * events a list of events related to the entity */ public void setEvents(List<TimelineEvent> events) { this.events = events; } /** * Get the related entities * * @return the related entities */ public Map<String, Set<String>> getRelatedEntities() { return relatedEntities; } // Required by JAXB @Private @XmlElement(name = "relatedentities") public HashMap<String, Set<String>> getRelatedEntitiesJAXB() { return relatedEntities; } /** * Add an entity to the existing related entity map * * @param entityType * the entity type * @param entityId * the entity Id */ public void addRelatedEntity(String entityType, String entityId) { Set<String> thisRelatedEntity = relatedEntities.get(entityType); if (thisRelatedEntity == null) { thisRelatedEntity = new HashSet<String>(); relatedEntities.put(entityType, thisRelatedEntity); } thisRelatedEntity.add(entityId); } /** * Add a map of related entities to the existing related entity map * * @param relatedEntities * a map of related entities */ public void addRelatedEntities(Map<String, Set<String>> relatedEntities) { for (Entry<String, Set<String>> relatedEntity : relatedEntities.entrySet()) { Set<String> thisRelatedEntity = this.relatedEntities.get(relatedEntity.getKey()); if (thisRelatedEntity == null) { this.relatedEntities.put(relatedEntity.getKey(), relatedEntity.getValue()); } else { thisRelatedEntity.addAll(relatedEntity.getValue()); } } } /** * Set the related entity map to the given map of related entities * * @param relatedEntities * a map of related entities */ public void setRelatedEntities(Map<String, Set<String>> relatedEntities) { this.relatedEntities = TimelineServiceHelper.mapCastToHashMap(relatedEntities); } /** * Get the primary filters * * @return the primary filters */ public Map<String, Set<Object>> getPrimaryFilters() { return primaryFilters; } // Required by JAXB @Private @XmlElement(name = "primaryfilters") public HashMap<String, Set<Object>> getPrimaryFiltersJAXB() { return primaryFilters; } /** * Add a single piece of primary filter to the existing primary filter map * * @param key * the primary filter key * @param value * the primary filter value */ public void addPrimaryFilter(String key, Object value) { Set<Object> thisPrimaryFilter = primaryFilters.get(key); if (thisPrimaryFilter == null) { thisPrimaryFilter = new HashSet<Object>(); primaryFilters.put(key, thisPrimaryFilter); } thisPrimaryFilter.add(value); } /** * Add a map of primary filters to the existing primary filter map * * @param primaryFilters * a map of primary filters */ public void addPrimaryFilters(Map<String, Set<Object>> primaryFilters) { for (Entry<String, Set<Object>> primaryFilter : primaryFilters.entrySet()) { Set<Object> thisPrimaryFilter = this.primaryFilters.get(primaryFilter.getKey()); if (thisPrimaryFilter == null) { this.primaryFilters.put(primaryFilter.getKey(), primaryFilter.getValue()); } else { thisPrimaryFilter.addAll(primaryFilter.getValue()); } } } /** * Set the primary filter map to the given map of primary filters * * @param primaryFilters * a map of primary filters */ public void setPrimaryFilters(Map<String, Set<Object>> primaryFilters) { this.primaryFilters = TimelineServiceHelper.mapCastToHashMap(primaryFilters); } /** * Get the other information of the entity * * @return the other information of the entity */ public Map<String, Object> getOtherInfo() { return otherInfo; } // Required by JAXB @Private @XmlElement(name = "otherinfo") public HashMap<String, Object> getOtherInfoJAXB() { return otherInfo; } /** * Add one piece of other information of the entity to the existing other info * map * * @param key * the other information key * @param value * the other information value */ public void addOtherInfo(String key, Object value) { this.otherInfo.put(key, value); } /** * Add a map of other information of the entity to the existing other info map * * @param otherInfo * a map of other information */ public void addOtherInfo(Map<String, Object> otherInfo) { this.otherInfo.putAll(otherInfo); } /** * Set the other info map to the given map of other information * * @param otherInfo * a map of other information */ public void setOtherInfo(Map<String, Object> otherInfo) { this.otherInfo = TimelineServiceHelper.mapCastToHashMap(otherInfo); } /** * Get the ID of the domain that the entity is to be put * * @return the domain ID */ @XmlElement(name = "domain") public String getDomainId() { return domainId; } /** * Set the ID of the domain that the entity is to be put * * @param domainId * the name space ID */ public void setDomainId(String domainId) { this.domainId = domainId; } @Override public int hashCode() { // generated by eclipse final int prime = 31; int result = 1; result = prime * result + ((entityId == null) ? 0 : entityId.hashCode()); result = prime * result + ((entityType == null) ? 0 : entityType.hashCode()); result = prime * result + ((events == null) ? 0 : events.hashCode()); result = prime * result + ((otherInfo == null) ? 0 : otherInfo.hashCode()); result = prime * result + ((primaryFilters == null) ? 0 : primaryFilters.hashCode()); result = prime * result + ((relatedEntities == null) ? 0 : relatedEntities.hashCode()); result = prime * result + ((startTime == null) ? 0 : startTime.hashCode()); return result; } @Override public boolean equals(Object obj) { // generated by eclipse if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; TimelineEntity other = (TimelineEntity) obj; if (entityId == null) { if (other.entityId != null) return false; } else if (!entityId.equals(other.entityId)) return false; if (entityType == null) { if (other.entityType != null) return false; } else if (!entityType.equals(other.entityType)) return false; if (events == null) { if (other.events != null) return false; } else if (!events.equals(other.events)) return false; if (otherInfo == null) { if (other.otherInfo != null) return false; } else if (!otherInfo.equals(other.otherInfo)) return false; if (primaryFilters == null) { if (other.primaryFilters != null) return false; } else if (!primaryFilters.equals(other.primaryFilters)) return false; if (relatedEntities == null) { if (other.relatedEntities != null) return false; } else if (!relatedEntities.equals(other.relatedEntities)) return false; if (startTime == null) { if (other.startTime != null) return false; } else if (!startTime.equals(other.startTime)) return false; return true; } @Override public int compareTo(TimelineEntity other) { int comparison = entityType.compareTo(other.entityType); if (comparison == 0) { long thisStartTime = startTime == null ? Long.MIN_VALUE : startTime; long otherStartTime = other.startTime == null ? Long.MIN_VALUE : other.startTime; if (thisStartTime > otherStartTime) { return -1; } else if (thisStartTime < otherStartTime) { return 1; } else { return entityId.compareTo(other.entityId); } } else { return comparison; } } }