gcr/spi/AbstractContent.java

   1 package org.argeo.api.gcr.spi;
   2
   3 import java.util.AbstractMap;
   4 import java.util.AbstractSet;
   5 import java.util.ArrayList;
   6 import java.util.Iterator;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Set;
  10
  11 import javax.xml.namespace.QName;
  12
  13 import org.argeo.api.gcr.Content;
  14 import org.argeo.api.gcr.CrName;
  15
  16 public abstract class AbstractContent extends AbstractMap<QName, Object> implements Content {
  17
  18         @Override
  19         public Set<Entry<QName, Object>> entrySet() {
  20 //              Set<Entry<String, Object>> result = new HashSet<>();
  21 //              for (String key : keys()) {
  22 //                      Entry<String, Object> entry = new Entry<String, Object>() {
  23 //
  24 //                              @Override
  25 //                              public String getKey() {
  26 //                                      return key;
  27 //                              }
  28 //
  29 //                              @Override
  30 //                              public Object getValue() {
  31 //                                      return get(key, Object.class);
  32 //                              }
  33 //
  34 //                              @Override
  35 //                              public Object setValue(Object value) {
  36 //                                      throw new UnsupportedOperationException();
  37 //                              }
  38 //
  39 //                      };
  40 //                      result.add(entry);
  41 //              }
  42                 Set<Entry<QName, Object>> result = new AttrSet();
  43                 return result;
  44         }
  45
  46         protected abstract Iterable<QName> keys();
  47
  48         protected abstract void removeAttr(QName key);
  49
  50         @Override
  51         public String getPath() {
  52                 List<Content> ancestors = new ArrayList<>();
  53                 collectAncestors(ancestors, this);
  54                 StringBuilder path = new StringBuilder();
  55                 for (Content c : ancestors) {
  56                         QName name = c.getName();
  57                         // FIXME
  58                         if (!CrName.ROOT.get().equals(name))
  59                                 path.append('/').append(name);
  60                 }
  61                 return path.toString();
  62         }
  63
  64         private void collectAncestors(List<Content> ancestors, Content content) {
  65                 if (content == null)
  66                         return;
  67                 ancestors.add(0, content);
  68                 collectAncestors(ancestors, content.getParent());
  69         }
  70
  71         /*
  72          * UTILITIES
  73          */
  74         protected boolean isDefaultAttrTypeRequested(Class<?> clss) {
  75                 // check whether clss is Object.class
  76                 return clss.isAssignableFrom(Object.class);
  77         }
  78
  79         @Override
  80         public String toString() {
  81                 return "content " + getPath();
  82         }
  83
  84         /*
  85          * SUB CLASSES
  86          */
  87
  88         class AttrSet extends AbstractSet<Entry<QName, Object>> {
  89
  90                 @Override
  91                 public Iterator<Entry<QName, Object>> iterator() {
  92                         final Iterator<QName> keys = keys().iterator();
  93                         Iterator<Entry<QName, Object>> it = new Iterator<Map.Entry<QName, Object>>() {
  94
  95                                 QName key = null;
  96
  97                                 @Override
  98                                 public boolean hasNext() {
  99                                         return keys.hasNext();
 100                                 }
 101
 102                                 @Override
 103                                 public Entry<QName, Object> next() {
 104                                         key = keys.next();
 105                                         // TODO check type
 106                                         Object value = get(key, Object.class);
 107                                         AbstractMap.SimpleEntry<QName, Object> entry = new SimpleEntry<>(key, value);
 108                                         return entry;
 109                                 }
 110
 111                                 @Override
 112                                 public void remove() {
 113                                         if (key != null) {
 114                                                 AbstractContent.this.removeAttr(key);
 115                                         } else {
 116                                                 throw new IllegalStateException("Iteration has not started");
 117                                         }
 118                                 }
 119
 120                         };
 121                         return it;
 122                 }
 123
 124                 @Override
 125                 public int size() {
 126                         int count = 0;
 127                         for (QName key : keys()) {
 128                                 count++;
 129                         }
 130                         return count;
 131                 }
 132
 133         }
 134 }