acr/AbstractContent.java

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