import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
+import javax.xml.namespace.QName;
+
import org.argeo.api.gcr.Content;
+import org.argeo.api.gcr.CrName;
+
+public abstract class AbstractContent extends AbstractMap<QName, Object> implements Content {
+
+ /*
+ * ATTRIBUTES OPERATIONS
+ */
+ protected abstract Iterable<QName> keys();
-public abstract class AbstractContent extends AbstractMap<String, Object> implements Content {
+ protected abstract void removeAttr(QName key);
@Override
- public Set<Entry<String, Object>> entrySet() {
-// Set<Entry<String, Object>> result = new HashSet<>();
-// for (String key : keys()) {
-// Entry<String, Object> entry = new Entry<String, Object>() {
-//
-// @Override
-// public String getKey() {
-// return key;
-// }
-//
-// @Override
-// public Object getValue() {
-// return get(key, Object.class);
-// }
-//
-// @Override
-// public Object setValue(Object value) {
-// throw new UnsupportedOperationException();
-// }
-//
-// };
-// result.add(entry);
-// }
- Set<Entry<String, Object>> result = new AttrSet();
+ public Set<Entry<QName, Object>> entrySet() {
+ Set<Entry<QName, Object>> result = new AttrSet();
return result;
}
- protected abstract Iterable<String> keys();
+ @Override
+ public Class<?> getType(QName key) {
+ return String.class;
+ }
+
+ @Override
+ public boolean isMultiple(QName key) {
+ return false;
+ }
+
+ @Override
+ public <A> Optional<List<A>> getMultiple(QName key, Class<A> clss) {
+ Object value = get(key);
+ if (value == null)
+ return null;
+ if (value instanceof List) {
+ try {
+ List<A> res = (List<A>) value;
+ return Optional.of(res);
+ } catch (ClassCastException e) {
+ List<A> res = new ArrayList<>();
+ List<?> lst = (List<?>) value;
+ try {
+ for (Object o : lst) {
+ A item = (A) o;
+ res.add(item);
+ }
+ return Optional.of(res);
+ } catch (ClassCastException e1) {
+ return Optional.empty();
+ }
+ }
+ } else {// singleton
+ try {
+ A res = (A) value;
+ return Optional.of(Collections.singletonList(res));
+ } catch (ClassCastException e) {
+ return Optional.empty();
+ }
+ }
+ }
- protected abstract void removeAttr(String key);
+ /*
+ * CONTENT OPERATIONS
+ */
@Override
public String getPath() {
collectAncestors(ancestors, this);
StringBuilder path = new StringBuilder();
for (Content c : ancestors) {
- String name = c.getName();
- if (!"".equals(name))
+ QName name = c.getName();
+ // FIXME
+ if (!CrName.ROOT.get().equals(name))
path.append('/').append(name);
}
return path.toString();
@Override
public String toString() {
- return "content "+getPath();
+ return "content " + getPath();
}
/*
* SUB CLASSES
*/
- class AttrSet extends AbstractSet<Entry<String, Object>> {
+ class AttrSet extends AbstractSet<Entry<QName, Object>> {
@Override
- public Iterator<Entry<String, Object>> iterator() {
- final Iterator<String> keys = keys().iterator();
- Iterator<Entry<String, Object>> it = new Iterator<Map.Entry<String, Object>>() {
+ public Iterator<Entry<QName, Object>> iterator() {
+ final Iterator<QName> keys = keys().iterator();
+ Iterator<Entry<QName, Object>> it = new Iterator<Map.Entry<QName, Object>>() {
- String key = null;
+ QName key = null;
@Override
public boolean hasNext() {
}
@Override
- public Entry<String, Object> next() {
+ public Entry<QName, Object> next() {
key = keys.next();
// TODO check type
- Object value = get(key, Object.class);
- AbstractMap.SimpleEntry<String, Object> entry = new SimpleEntry<>(key, value);
+ Optional<?> value = get(key, Object.class);
+ assert !value.isEmpty();
+ AbstractMap.SimpleEntry<QName, Object> entry = new SimpleEntry<>(key, value.get());
return entry;
}
@Override
public int size() {
int count = 0;
- for (String key : keys()) {
+ for (QName key : keys()) {
count++;
}
return count;