org.argeo.api.acr/src/org/argeo/api/acr/spi/AbstractContent.java

   1 package org.argeo.api.acr.spi;
   2
   3 import java.util.AbstractMap;
   4 import java.util.AbstractSet;
   5 import java.util.ArrayList;
   6 import java.util.Collections;
   7 import java.util.Iterator;
   8 import java.util.List;
   9 import java.util.Map;
  10 import java.util.Optional;
  11 import java.util.Set;
  12
  13 import javax.xml.namespace.QName;
  14
  15 import org.argeo.api.acr.Content;
  16 import org.argeo.api.acr.CrName;
  17
  18 /** Partial reference implementation of a {@link ProvidedContent}. */
  19 public abstract class AbstractContent extends AbstractMap<QName, Object> implements ProvidedContent {
  20
  21         /*
  22          * ATTRIBUTES OPERATIONS
  23          */
  24         protected abstract Iterable<QName> keys();
  25
  26         protected abstract void removeAttr(QName key);
  27
  28         @Override
  29         public Set<Entry<QName, Object>> entrySet() {
  30                 Set<Entry<QName, Object>> result = new AttrSet();
  31                 return result;
  32         }
  33
  34         @Override
  35         public Class<?> getType(QName key) {
  36                 return String.class;
  37         }
  38
  39         @Override
  40         public boolean isMultiple(QName key) {
  41                 return false;
  42         }
  43
  44         @SuppressWarnings("unchecked")
  45         @Override
  46         public <A> Optional<List<A>> getMultiple(QName key, Class<A> clss) {
  47                 Object value = get(key);
  48                 if (value == null)
  49                         return null;
  50                 if (value instanceof List) {
  51                         try {
  52                                 List<A> res = (List<A>) value;
  53                                 return Optional.of(res);
  54                         } catch (ClassCastException e) {
  55                                 List<A> res = new ArrayList<>();
  56                                 List<?> lst = (List<?>) value;
  57                                 try {
  58                                         for (Object o : lst) {
  59                                                 A item = (A) o;
  60                                                 res.add(item);
  61                                         }
  62                                         return Optional.of(res);
  63                                 } catch (ClassCastException e1) {
  64                                         return Optional.empty();
  65                                 }
  66                         }
  67                 } else {// singleton
  68                         try {
  69                                 A res = (A) value;
  70                                 return Optional.of(Collections.singletonList(res));
  71                         } catch (ClassCastException e) {
  72                                 return Optional.empty();
  73                         }
  74                 }
  75         }
  76
  77         /*
  78          * CONTENT OPERATIONS
  79          */
  80
  81         @Override
  82         public String getPath() {
  83                 List<Content> ancestors = new ArrayList<>();
  84                 collectAncestors(ancestors, this);
  85                 StringBuilder path = new StringBuilder();
  86                 for (Content c : ancestors) {
  87                         QName name = c.getName();
  88                         // FIXME
  89                         if (!CrName.ROOT.get().equals(name))
  90                                 path.append('/').append(name);
  91                 }
  92                 return path.toString();
  93         }
  94
  95         private void collectAncestors(List<Content> ancestors, Content content) {
  96                 if (content == null)
  97                         return;
  98                 ancestors.add(0, content);
  99                 collectAncestors(ancestors, content.getParent());
 100         }
 101
 102         /*
 103          * UTILITIES
 104          */
 105         protected boolean isDefaultAttrTypeRequested(Class<?> clss) {
 106                 // check whether clss is Object.class
 107                 return clss.isAssignableFrom(Object.class);
 108         }
 109
 110         @Override
 111         public String toString() {
 112                 return "content " + getPath();
 113         }
 114
 115         /*
 116          * SUB CLASSES
 117          */
 118
 119         class AttrSet extends AbstractSet<Entry<QName, Object>> {
 120
 121                 @Override
 122                 public Iterator<Entry<QName, Object>> iterator() {
 123                         final Iterator<QName> keys = keys().iterator();
 124                         Iterator<Entry<QName, Object>> it = new Iterator<Map.Entry<QName, Object>>() {
 125
 126                                 QName key = null;
 127
 128                                 @Override
 129                                 public boolean hasNext() {
 130                                         return keys.hasNext();
 131                                 }
 132
 133                                 @Override
 134                                 public Entry<QName, Object> next() {
 135                                         key = keys.next();
 136                                         // TODO check type
 137                                         Optional<?> value = get(key, Object.class);
 138                                         assert !value.isEmpty();
 139                                         AbstractMap.SimpleEntry<QName, Object> entry = new SimpleEntry<>(key, value.get());
 140                                         return entry;
 141                                 }
 142
 143                                 @Override
 144                                 public void remove() {
 145                                         if (key != null) {
 146                                                 AbstractContent.this.removeAttr(key);
 147                                         } else {
 148                                                 throw new IllegalStateException("Iteration has not started");
 149                                         }
 150                                 }
 151
 152                         };
 153                         return it;
 154                 }
 155
 156                 @Override
 157                 public int size() {
 158
 159                         int count = 0;
 160                         for (Iterator<QName> it = keys().iterator(); it.hasNext();) {
 161                                 count++;
 162                         }
 163                         return count;
 164                 }
 165
 166         }
 167 }