org.argeo.enterprise/src/org/argeo/osgi/provisioning/SimpleProvisioningService.java

   1 package org.argeo.osgi.provisioning;
   2
   3 import java.io.IOException;
   4 import java.util.Collections;
   5 import java.util.Dictionary;
   6 import java.util.Enumeration;
   7 import java.util.Iterator;
   8 import java.util.Map;
   9 import java.util.TreeMap;
  10 import java.util.zip.ZipInputStream;
  11
  12 import org.osgi.service.provisioning.ProvisioningService;
  13
  14 public class SimpleProvisioningService implements ProvisioningService {
  15         private Map<String, Object> map = Collections.synchronizedSortedMap(new TreeMap<>());
  16
  17         public SimpleProvisioningService() {
  18                 // update count
  19                 map.put(PROVISIONING_UPDATE_COUNT, 0);
  20         }
  21
  22         @Override
  23         public Dictionary<String, Object> getInformation() {
  24                 return new Information();
  25         }
  26
  27         @Override
  28         public synchronized void setInformation(Dictionary<String, ?> info) {
  29                 map.clear();
  30                 addInformation(info);
  31         }
  32
  33         @Override
  34         public synchronized void addInformation(Dictionary<String, ?> info) {
  35                 Enumeration<String> e = info.keys();
  36                 while (e.hasMoreElements()) {
  37                         String key = e.nextElement();
  38                         map.put(key, info.get(key));
  39                 }
  40                 incrementProvisioningUpdateCount();
  41         }
  42
  43         protected synchronized void incrementProvisioningUpdateCount() {
  44                 Integer current = (Integer) map.get(PROVISIONING_UPDATE_COUNT);
  45                 Integer newValue = current + 1;
  46                 map.put(PROVISIONING_UPDATE_COUNT, newValue);
  47         }
  48
  49         @Override
  50         public synchronized void addInformation(ZipInputStream zis) throws IOException {
  51                 throw new UnsupportedOperationException();
  52         }
  53
  54         class Information extends Dictionary<String, Object> {
  55
  56                 @Override
  57                 public int size() {
  58                         return map.size();
  59                 }
  60
  61                 @Override
  62                 public boolean isEmpty() {
  63                         return map.isEmpty();
  64                 }
  65
  66                 @Override
  67                 public Enumeration<String> keys() {
  68                         Iterator<String> it = map.keySet().iterator();
  69                         return new Enumeration<String>() {
  70
  71                                 @Override
  72                                 public boolean hasMoreElements() {
  73                                         return it.hasNext();
  74                                 }
  75
  76                                 @Override
  77                                 public String nextElement() {
  78                                         return it.next();
  79                                 }
  80
  81                         };
  82                 }
  83
  84                 @Override
  85                 public Enumeration<Object> elements() {
  86                         Iterator<Object> it = map.values().iterator();
  87                         return new Enumeration<Object>() {
  88
  89                                 @Override
  90                                 public boolean hasMoreElements() {
  91                                         return it.hasNext();
  92                                 }
  93
  94                                 @Override
  95                                 public Object nextElement() {
  96                                         return it.next();
  97                                 }
  98
  99                         };
 100                 }
 101
 102                 @Override
 103                 public Object get(Object key) {
 104                         return map.get(key);
 105                 }
 106
 107                 @Override
 108                 public Object put(String key, Object value) {
 109                         throw new UnsupportedOperationException();
 110                 }
 111
 112                 @Override
 113                 public Object remove(Object key) {
 114                         throw new UnsupportedOperationException();
 115                 }
 116
 117         }
 118 }