core/org.argeo.suite.core/src/org/argeo/suite/RankedObject.java

   1 package org.argeo.suite;
   2
   3 import java.util.Map;
   4
   5 import org.apache.commons.logging.Log;
   6 import org.apache.commons.logging.LogFactory;
   7
   8 /**
   9  * A container for an object whose relevance can be ranked. Typically used in an
  10  * OSGi context with the service.ranking property.
  11  */
  12 public class RankedObject<T> {
  13         private final static Log log = LogFactory.getLog(RankedObject.class);
  14
  15         private final static String SERVICE_RANKING = "service.ranking";
  16 //      private final static String SERVICE_ID = "service.id";
  17
  18         private T object;
  19         private Map<String, Object> properties;
  20         private final Long rank;
  21
  22         public RankedObject(T object, Map<String, Object> properties) {
  23                 this(object, properties, extractRanking(properties));
  24         }
  25
  26         public RankedObject(T object, Map<String, Object> properties, Long rank) {
  27                 super();
  28                 this.object = object;
  29                 this.properties = properties;
  30                 this.rank = rank;
  31         }
  32
  33         private static Long extractRanking(Map<String, Object> properties) {
  34                 if (properties == null)
  35                         return 0l;
  36                 if (properties.containsKey(SERVICE_RANKING))
  37                         return Long.valueOf(properties.get(SERVICE_RANKING).toString());
  38 //              else if (properties.containsKey(SERVICE_ID))
  39 //                      return (Long) properties.get(SERVICE_ID);
  40                 else
  41                         return 0l;
  42         }
  43
  44         public T get() {
  45                 return object;
  46         }
  47
  48         public Map<String, Object> getProperties() {
  49                 return properties;
  50         }
  51
  52         public Long getRank() {
  53                 return rank;
  54         }
  55
  56         @Override
  57         public int hashCode() {
  58                 return object.hashCode();
  59         }
  60
  61         @Override
  62         public boolean equals(Object obj) {
  63                 if (!(obj instanceof RankedObject))
  64                         return false;
  65                 RankedObject<?> other = (RankedObject<?>) obj;
  66                 return rank.equals(other.rank) && object.equals(other.object);
  67         }
  68
  69         @Override
  70         public String toString() {
  71                 return object.getClass().getName() + " with rank " + rank;
  72         }
  73
  74         public static <K, T> RankedObject<T> putIfHigherRank(Map<K, RankedObject<T>> map, K key, T object,
  75                         Map<String, Object> properties) {
  76                 RankedObject<T> rankedObject = new RankedObject<>(object, properties);
  77                 if (!map.containsKey(key)) {
  78                         map.put(key, rankedObject);
  79                         if (log.isTraceEnabled())
  80                                 log.trace(
  81                                                 "Added " + key + " as " + object.getClass().getName() + " with rank " + rankedObject.getRank());
  82                         return rankedObject;
  83                 } else {
  84                         RankedObject<T> current = map.get(key);
  85                         if (current.getRank() <= rankedObject.getRank()) {
  86                                 map.put(key, rankedObject);
  87                                 if (log.isTraceEnabled())
  88                                         log.trace("Replaced " + key + " by " + object.getClass().getName() + " with rank "
  89                                                         + rankedObject.getRank());
  90                                 return rankedObject;
  91                         } else {
  92                                 return current;
  93                         }
  94                 }
  95
  96         }
  97
  98 }