org.argeo.app.api/src/org/argeo/app/api/RankedObject.java

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