org.argeo.api.acr/src/org/argeo/api/acr/Content.java

   1 package org.argeo.api.acr;
   2
   3 import java.util.List;
   4 import java.util.Map;
   5 import java.util.Optional;
   6
   7 import javax.xml.XMLConstants;
   8 import javax.xml.namespace.QName;
   9
  10 /**
  11  * A semi-structured content, with attributes, within a hierarchical structure.
  12  */
  13 public interface Content extends Iterable<Content>, Map<QName, Object> {
  14
  15         QName getName();
  16
  17         String getPath();
  18
  19         Content getParent();
  20
  21         /*
  22          * ATTRIBUTES OPERATIONS
  23          */
  24
  25         <A> Optional<A> get(QName key, Class<A> clss);
  26
  27         default Object get(String key) {
  28                 if (key.indexOf(':') >= 0)
  29                         throw new IllegalArgumentException("Name " + key + " has a prefix");
  30                 return get(new QName(XMLConstants.NULL_NS_URI, key, XMLConstants.DEFAULT_NS_PREFIX));
  31         }
  32
  33         default Object put(String key, Object value) {
  34                 if (key.indexOf(':') >= 0)
  35                         throw new IllegalArgumentException("Name " + key + " has a prefix");
  36                 return put(new QName(XMLConstants.NULL_NS_URI, key, XMLConstants.DEFAULT_NS_PREFIX), value);
  37         }
  38
  39         default Object remove(String key) {
  40                 if (key.indexOf(':') >= 0)
  41                         throw new IllegalArgumentException("Name " + key + " has a prefix");
  42                 return remove(new QName(XMLConstants.NULL_NS_URI, key, XMLConstants.DEFAULT_NS_PREFIX));
  43         }
  44
  45         Class<?> getType(QName key);
  46
  47         boolean isMultiple(QName key);
  48
  49         <A> Optional<List<A>> getMultiple(QName key, Class<A> clss);
  50
  51         default <A> List<A> getMultiple(QName key) {
  52                 Class<A> type;
  53                 try {
  54                         type = (Class<A>) getType(key);
  55                 } catch (ClassCastException e) {
  56                         throw new IllegalArgumentException("Requested type is not the default type");
  57                 }
  58                 Optional<List<A>> res = getMultiple(key, type);
  59                 if (res == null)
  60                         return null;
  61                 else {
  62                         if (res.isEmpty())
  63                                 throw new IllegalStateException("Metadata " + key + " is not availabel as list of type " + type);
  64                         return res.get();
  65                 }
  66         }
  67
  68         /*
  69          * CONTENT OPERATIONS
  70          */
  71         Content add(QName name, QName... classes);
  72
  73         default Content add(String name, QName... classes) {
  74                 if (name.indexOf(':') >= 0)
  75                         throw new IllegalArgumentException("Name " + name + " has a prefix");
  76                 return add(new QName(XMLConstants.NULL_NS_URI, name, XMLConstants.DEFAULT_NS_PREFIX), classes);
  77         }
  78
  79         void remove();
  80
  81         /*
  82          * DEFAULT METHODS
  83          */
  84         default <A> A adapt(Class<A> clss) throws IllegalArgumentException {
  85                 throw new IllegalArgumentException("Cannot adapt content " + this + " to " + clss.getName());
  86         }
  87
  88         default <C extends AutoCloseable> C open(Class<C> clss) throws Exception, IllegalArgumentException {
  89                 throw new IllegalArgumentException("Cannot open content " + this + " as " + clss.getName());
  90         }
  91
  92         /*
  93          * CONVENIENCE METHODS
  94          */
  95 //      default String attr(String key) {
  96 //              return get(key, String.class);
  97 //      }
  98 //
  99 //      default String attr(Object key) {
 100 //              return key != null ? attr(key.toString()) : attr(null);
 101 //      }
 102 //
 103 //      default <A> A get(Object key, Class<A> clss) {
 104 //              return key != null ? get(key.toString(), clss) : get(null, clss);
 105 //      }
 106
 107         /*
 108          * EXPERIMENTAL UNSUPPORTED
 109          */
 110         default boolean hasText() {
 111                 return false;
 112         }
 113
 114         default String getText() {
 115                 throw new UnsupportedOperationException();
 116         }
 117
 118 }