package org.argeo.api.acr;
+import javax.xml.namespace.NamespaceContext;
+
/**
* An attribute type MUST consistently parse a string to an object so that
* <code>parse(obj.toString()).equals(obj)</code> is verified.
*/
public interface AttributeFormatter<T> {
/** Parses a String to a Java object. */
- T parse(String str) throws IllegalArgumentException;
+ default T parse(String str) throws IllegalArgumentException {
+ return parse(RuntimeNamespaceContext.getNamespaceContext(), str);
+ }
+
+ /**
+ * Parses a String to a Java object, possibly using the namespace context to
+ * resolve QName or CURIE.
+ */
+ T parse(NamespaceContext namespaceContext, String str) throws IllegalArgumentException;
/** Default implementation returns {@link Object#toString()} on the argument. */
default String format(T obj) {
*/
@Override
- public String toString() {
+ public final String toString() {
return toQNameString();
}
import java.util.Locale;
import java.util.concurrent.CompletionStage;
import java.util.function.Consumer;
-import java.util.function.Supplier;
import java.util.stream.Stream;
import javax.security.auth.Subject;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
-import java.util.Objects;
import java.util.Optional;
import java.util.UUID;
+import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
/**
// (e.g. optional primitives)
DATE_TIME(Instant.class, W3C_XML_SCHEMA_NS_URI, "dateTime", new InstantFormatter()), //
UUID(UUID.class, ArgeoNamespace.CR_NAMESPACE_URI, "uuid", new UuidFormatter()), //
+ QNAME(QName.class, W3C_XML_SCHEMA_NS_URI, "QName", new QNameFormatter()), //
ANY_URI(URI.class, W3C_XML_SCHEMA_NS_URI, "anyUri", new UriFormatter()), //
STRING(String.class, W3C_XML_SCHEMA_NS_URI, "string", new StringFormatter()), //
;
qName = new ContentName(namespaceUri, localName, RuntimeNamespaceContext.getNamespaceContext());
}
- public QName getqName() {
+ public QName getQName() {
return qName;
}
/** Default parsing procedure from a String to an object. */
public static Object parse(String str) {
+ return parse(RuntimeNamespaceContext.getNamespaceContext(), str);
+ }
+
+ /** Default parsing procedure from a String to an object. */
+ public static Object parse(NamespaceContext namespaceContext, String str) {
if (str == null)
throw new IllegalArgumentException("String cannot be null");
// order IS important
try {
if (str.length() == 4 || str.length() == 5)
- return BOOLEAN.getFormatter().parse(str);
+ return BOOLEAN.getFormatter().parse(namespaceContext, str);
} catch (IllegalArgumentException e) {
// silent
}
try {
- return INTEGER.getFormatter().parse(str);
+ return INTEGER.getFormatter().parse(namespaceContext, str);
} catch (IllegalArgumentException e) {
// silent
}
try {
- return LONG.getFormatter().parse(str);
+ return LONG.getFormatter().parse(namespaceContext, str);
} catch (IllegalArgumentException e) {
// silent
}
try {
- return DOUBLE.getFormatter().parse(str);
+ return DOUBLE.getFormatter().parse(namespaceContext, str);
} catch (IllegalArgumentException e) {
// silent
}
try {
- return DATE_TIME.getFormatter().parse(str);
+ return DATE_TIME.getFormatter().parse(namespaceContext, str);
} catch (IllegalArgumentException e) {
// silent
}
try {
if (str.length() == 36)
- return UUID.getFormatter().parse(str);
+ return UUID.getFormatter().parse(namespaceContext, str);
+ } catch (IllegalArgumentException e) {
+ // silent
+ }
+
+ // CURIE
+ if (str.startsWith("[") && str.endsWith("]")) {
+ try {
+ if (str.indexOf(":") >= 0) {
+ QName qName = (QName) QNAME.getFormatter().parse(namespaceContext, str);
+ return (java.net.URI) ANY_URI.getFormatter().parse(qName.getNamespaceURI() + qName.getLocalPart());
+ }
+ } catch (IllegalArgumentException e) {
+ // silent
+ }
+ }
+
+ try {
+ if (str.indexOf(":") >= 0) {
+ QName qName = (QName) QNAME.getFormatter().parse(namespaceContext, str);
+ // note: this QName may not be valid
+ // note: CURIE should be explicitly defined with surrounding brackets
+ return qName;
+ }
} catch (IllegalArgumentException e) {
// silent
}
try {
- java.net.URI uri = (java.net.URI) ANY_URI.getFormatter().parse(str);
+ java.net.URI uri = (java.net.URI) ANY_URI.getFormatter().parse(namespaceContext, str);
if (uri.getScheme() != null)
return uri;
String path = uri.getPath();
// see https://www.oreilly.com/library/view/xml-schema/0596002521/re91.html
// default
- return STRING.getFormatter().parse(str);
+ return STRING.getFormatter().parse(namespaceContext, str);
}
/**
* object.
*
*/
- @SuppressWarnings("unchecked")
public static <T> Optional<T> cast(Class<T> clss, Object value) {
- // TODO Or should we?
- Objects.requireNonNull(value, "Cannot cast a null value");
+ return cast(RuntimeNamespaceContext.getNamespaceContext(), clss, value);
+ }
+
+ /**
+ * Cast well know java types based on {@link Object#toString()} of the provided
+ * object.
+ *
+ */
+ @SuppressWarnings("unchecked")
+ public static <T> Optional<T> cast(NamespaceContext namespaceContext, Class<T> clss, Object value) {
+ // if value is null, optional is empty
+ if (value == null)
+ return Optional.empty();
+
+ // if a default has been explicitly requested by passing Object.class
+ // we parse the related String
+ if (clss.isAssignableFrom(Object.class)) {
+ return Optional.of((T) parse(value.toString()));
+ }
+
+ // if value can be cast directly, let's do it
+ if (value.getClass().isAssignableFrom(clss)) {
+ return Optional.of(((T) value));
+ }
+
+ // let's cast between various numbers (possibly losing precision)
+ if (value instanceof Number number) {
+ if (Long.class.isAssignableFrom(clss))
+ return Optional.of((T) (Long) number.longValue());
+ else if (Integer.class.isAssignableFrom(clss))
+ return Optional.of((T) (Integer) number.intValue());
+ else if (Double.class.isAssignableFrom(clss))
+ return Optional.of((T) (Double) number.doubleValue());
+ }
+
+ // let's now try with the string representation
+ String strValue = value instanceof String ? (String) value : value.toString();
+
if (String.class.isAssignableFrom(clss)) {
- return Optional.of((T) value.toString());
+ return Optional.of((T) strValue);
+ }
+ if (QName.class.isAssignableFrom(clss)) {
+ return Optional.of((T) NamespaceUtils.parsePrefixedName(namespaceContext, strValue));
}
// Numbers
else if (Long.class.isAssignableFrom(clss)) {
if (value instanceof Long)
return Optional.of((T) value);
- return Optional.of((T) Long.valueOf(value.toString()));
+ return Optional.of((T) Long.valueOf(strValue));
} else if (Integer.class.isAssignableFrom(clss)) {
if (value instanceof Integer)
return Optional.of((T) value);
- return Optional.of((T) Integer.valueOf(value.toString()));
+ return Optional.of((T) Integer.valueOf(strValue));
} else if (Double.class.isAssignableFrom(clss)) {
if (value instanceof Double)
return Optional.of((T) value);
- return Optional.of((T) Double.valueOf(value.toString()));
+ return Optional.of((T) Double.valueOf(strValue));
}
- // Numbers
-// else if (Number.class.isAssignableFrom(clss)) {
-// if (value instanceof Number)
-// return Optional.of((T) value);
-// return Optional.of((T) Number.valueOf(value.toString()));
-// }
- return Optional.empty();
+
+ // let's now try to parse the string representation to a well-known type
+ Object parsedValue = parse(strValue);
+ if (parsedValue.getClass().isAssignableFrom(clss)) {
+ return Optional.of(((T) value));
+ }
+ throw new ClassCastException("Cannot convert " + value.getClass() + " to " + clss);
}
/** Utility to convert a data: URI to bytes. */
* contract than {@link Boolean#parseBoolean(String)}.
*/
@Override
- public Boolean parse(String str) throws IllegalArgumentException {
+ public Boolean parse(NamespaceContext namespaceContext, String str) throws IllegalArgumentException {
if ("true".equals(str))
return Boolean.TRUE;
if ("false".equals(str))
static class IntegerFormatter implements AttributeFormatter<Integer> {
@Override
- public Integer parse(String str) throws NumberFormatException {
+ public Integer parse(NamespaceContext namespaceContext, String str) throws NumberFormatException {
return Integer.parseInt(str);
}
}
static class LongFormatter implements AttributeFormatter<Long> {
@Override
- public Long parse(String str) throws NumberFormatException {
+ public Long parse(NamespaceContext namespaceContext, String str) throws NumberFormatException {
return Long.parseLong(str);
}
}
static class DoubleFormatter implements AttributeFormatter<Double> {
@Override
- public Double parse(String str) throws NumberFormatException {
+ public Double parse(NamespaceContext namespaceContext, String str) throws NumberFormatException {
return Double.parseDouble(str);
}
}
static class InstantFormatter implements AttributeFormatter<Instant> {
@Override
- public Instant parse(String str) throws IllegalArgumentException {
+ public Instant parse(NamespaceContext namespaceContext, String str) throws IllegalArgumentException {
try {
return Instant.parse(str);
} catch (DateTimeParseException e) {
static class UuidFormatter implements AttributeFormatter<UUID> {
@Override
- public UUID parse(String str) throws IllegalArgumentException {
+ public UUID parse(NamespaceContext namespaceContext, String str) throws IllegalArgumentException {
return java.util.UUID.fromString(str);
}
}
static class UriFormatter implements AttributeFormatter<URI> {
@Override
- public URI parse(String str) throws IllegalArgumentException {
+ public URI parse(NamespaceContext namespaceContext, String str) throws IllegalArgumentException {
try {
return new URI(str);
} catch (URISyntaxException e) {
}
+ static class QNameFormatter implements AttributeFormatter<QName> {
+
+ @Override
+ public QName parse(NamespaceContext namespaceContext, String str) throws IllegalArgumentException {
+ return NamespaceUtils.parsePrefixedName(namespaceContext, str);
+ }
+
+ }
+
static class StringFormatter implements AttributeFormatter<String> {
@Override
- public String parse(String str) {
+ public String parse(NamespaceContext namespaceContext, String str) {
return str;
}
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
+/** Static utilities around namespaces and prefixes. */
public class NamespaceUtils {
+ /**
+ * A {@link Comparator} ordering by namespace (full URI) and then local part.
+ */
+ public final static Comparator<QName> QNAME_COMPARATOR = new Comparator<QName>() {
+
+ @Override
+ public int compare(QName qn1, QName qn2) {
+ if (Objects.equals(qn1.getNamespaceURI(), qn2.getNamespaceURI())) {// same namespace
+ return qn1.getLocalPart().compareTo(qn2.getLocalPart());
+ } else {
+ return qn1.getNamespaceURI().compareTo(qn2.getNamespaceURI());
+ }
+ }
+ };
+
+ /**
+ * Return a {@link ContentName} from a prefixed name, using the default runtime
+ * {@link NamespaceContext}.
+ *
+ * @see RuntimeNamespaceContext#getNamespaceContext()
+ */
public static ContentName parsePrefixedName(String nameWithPrefix) {
return parsePrefixedName(RuntimeNamespaceContext.getNamespaceContext(), nameWithPrefix);
}
+ /**
+ * Return a {@link ContentName} from a prefixed name, using the provided
+ * {@link NamespaceContext}. Since {@link QName#QName(String, String)} does not
+ * validate, it can conceptually parse a CURIE.
+ *
+ * @see https://en.wikipedia.org/wiki/CURIE
+ */
public static ContentName parsePrefixedName(NamespaceContext nameSpaceContext, String nameWithPrefix) {
Objects.requireNonNull(nameWithPrefix, "Name cannot be null");
if (nameWithPrefix.charAt(0) == '{') {
String localName = nameWithPrefix.substring(index + 1);
String namespaceURI = nameSpaceContext.getNamespaceURI(prefix);
if (XMLConstants.NULL_NS_URI.equals(namespaceURI))
- throw new IllegalStateException("Prefix " + prefix + " is unbound.");
+ throw new IllegalArgumentException("Prefix " + prefix + " is unbound.");
return new ContentName(namespaceURI, localName, prefix);
}
+ /**
+ * The prefixed name of this {@link QName}, using the default runtime
+ * {@link NamespaceContext}.
+ *
+ * @see RuntimeNamespaceContext#getNamespaceContext()
+ */
public static String toPrefixedName(QName name) {
return toPrefixedName(RuntimeNamespaceContext.getNamespaceContext(), name);
}
+ /**
+ * The prefixed name of this {@link QName}, using the provided
+ * {@link NamespaceContext}.
+ */
public static String toPrefixedName(NamespaceContext nameSpaceContext, QName name) {
if (XMLConstants.NULL_NS_URI.equals(name.getNamespaceURI()))
return name.getLocalPart();
return prefix + ":" + name.getLocalPart();
}
- public final static Comparator<QName> QNAME_COMPARATOR = new Comparator<QName>() {
-
- @Override
- public int compare(QName qn1, QName qn2) {
- if (Objects.equals(qn1.getNamespaceURI(), qn2.getNamespaceURI())) {// same namespace
- return qn1.getLocalPart().compareTo(qn2.getLocalPart());
- } else {
- return qn1.getNamespaceURI().compareTo(qn2.getNamespaceURI());
- }
- }
-
- };
-
+ /**
+ * Whether thei {@link QName} has a namespace, that is its namespace is not
+ * {@link XMLConstants#NULL_NS_URI}.
+ */
public static boolean hasNamespace(QName qName) {
return !qName.getNamespaceURI().equals(XMLConstants.NULL_NS_URI);
}
- public static void checkNoPrefix(String unqualified) {
+ /** Throws an exception if the provided string has a prefix. */
+ public static void checkNoPrefix(String unqualified) throws IllegalArgumentException {
if (unqualified.indexOf(':') >= 0)
throw new IllegalArgumentException("Name " + unqualified + " has a prefix");
}
+ /**
+ * Create an unqualified {@link QName}, checking that the argument does not
+ * contain a prefix.
+ */
public static QName unqualified(String name) {
checkNoPrefix(name);
return new ContentName(XMLConstants.NULL_NS_URI, name, XMLConstants.DEFAULT_NS_PREFIX);
}
+ /**
+ * The common (fully qualified) representation of this name, as defined in
+ * {@link QName#toString()}. This should be used when a fully qualified
+ * representation is required, as subclasses of {@link QName} may override the
+ * {@link QName#toString()} method.
+ *
+ * @see ContentName#toString()
+ */
+ public static String toFullyQualified(QName name) {
+ if (name.getNamespaceURI().equals(XMLConstants.NULL_NS_URI)) {
+ return name.getLocalPart();
+ } else {
+ return "{" + name.getNamespaceURI() + "}" + name.getLocalPart();
+ }
+
+ }
+
/*
- * DEFAULT NAMESPACE CONTEXT OPERATIONS as specified in NamespaceContext
+ * STANDARD NAMESPACE CONTEXT OPERATIONS as specified in NamespaceContext
+ */
+ /**
+ * The standard prefix for well known namespaces as defined in
+ * {@link NamespaceContext}, or null if the namespace is not well-known. Helper
+ * method simplifying the implementation of a {@link NamespaceContext}.
+ *
+ * @see NamespaceContext#getPrefix(String)
*/
public static String getStandardPrefix(String namespaceURI) {
if (namespaceURI == null)
return null;
}
+ /**
+ * The standard prefixes for well known namespaces as defined in
+ * {@link NamespaceContext}, or null if the namespace is not well-known. Helper
+ * method simplifying the implementation of a {@link NamespaceContext}.
+ *
+ * @see NamespaceContext#getPrefixes(String)
+ */
public static Iterator<String> getStandardPrefixes(String namespaceURI) {
String prefix = getStandardPrefix(namespaceURI);
if (prefix == null)
return Collections.singleton(prefix).iterator();
}
+ /**
+ * The standard URI for well known prefixes as defined in
+ * {@link NamespaceContext}, or null if the prefix is not well-known. Helper
+ * method simplifying the implementation of a {@link NamespaceContext}.
+ *
+ * @see NamespaceContext#getNamespaceURI(String)
+ */
public static String getStandardNamespaceURI(String prefix) {
if (prefix == null)
throw new IllegalArgumentException("Prefix cannot be null");
return null;
}
+ /**
+ * The namespace URI for a given prefix, based on the provided mapping and the
+ * standard prefixes/URIs.
+ *
+ * @return the namespace URI for this prefix, or
+ * {@link XMLConstants#NULL_NS_URI} if unknown.
+ */
public static String getNamespaceURI(Function<String, String> mapping, String prefix) {
String namespaceURI = NamespaceUtils.getStandardNamespaceURI(prefix);
if (namespaceURI != null)
return XMLConstants.NULL_NS_URI;
}
+ /**
+ * The prefix for a given namespace URI, based on the provided mapping and the
+ * standard prefixes/URIs.
+ *
+ * @return the prefix for this namespace URI. What is returned or throws as
+ * exception if the prefix is not found depdnds on the mapping function.
+ */
public static String getPrefix(Function<String, String> mapping, String namespaceURI) {
String prefix = NamespaceUtils.getStandardPrefix(namespaceURI);
if (prefix != null)
return mapping.apply(namespaceURI);
}
+ /**
+ * The prefixes for a given namespace URI, based on the provided mapping and the
+ * standard prefixes/URIs.
+ *
+ * @return the prefixes for this namespace URI. What is returned or throws as
+ * exception if the prefix is not found depdnds on the mapping function.
+ */
public static Iterator<String> getPrefixes(Function<String, Set<String>> mapping, String namespaceURI) {
Iterator<String> standard = NamespaceUtils.getStandardPrefixes(namespaceURI);
if (standard != null)
import javax.xml.namespace.NamespaceContext;
/**
- * Programmatically defined {@link NamespaceContext}, code contributing
- * namespaces MUST register here with a single default prefix.
+ * Programmatically defined {@link NamespaceContext}, which is valid at runtime
+ * (when the software is running). Code contributing namespaces MUST register
+ * here with a single default prefix, nad MUST make sure that stored data
+ * contains the fully qualified namespace URI.
*/
public class RuntimeNamespaceContext implements NamespaceContext {
public final static String XSD_DEFAULT_PREFIX = "xs";
private NavigableMap<String, String> prefixes = new TreeMap<>();
private NavigableMap<String, String> namespaces = new TreeMap<>();
+ /*
+ * NAMESPACE CONTEXT IMPLEMENTATION
+ */
+
@Override
- public String getPrefix(String namespaceURI) {
+ public String getPrefix(String namespaceURI) throws IllegalArgumentException {
return NamespaceUtils.getPrefix((ns) -> {
String prefix = namespaces.get(ns);
if (prefix == null)
- throw new IllegalStateException("Namespace " + ns + " is not registered.");
+ throw new IllegalArgumentException("Namespace " + ns + " is not registered.");
return prefix;
}, namespaceURI);
}
@Override
- public String getNamespaceURI(String prefix) {
+ public String getNamespaceURI(String prefix) throws IllegalArgumentException {
return NamespaceUtils.getNamespaceURI((p) -> {
String ns = prefixes.get(p);
if (ns == null)
- throw new IllegalStateException("Prefix " + p + " is not registered.");
+ throw new IllegalArgumentException("Prefix " + p + " is not registered.");
return ns;
}, prefix);
}
@Override
- public Iterator<String> getPrefixes(String namespaceURI) {
+ public Iterator<String> getPrefixes(String namespaceURI) throws IllegalArgumentException {
return Collections.singleton(getPrefix(namespaceURI)).iterator();
}
/*
* STATIC
*/
-
private final static RuntimeNamespaceContext INSTANCE = new RuntimeNamespaceContext();
static {
register(ArgeoNamespace.ROLE_NAMESPACE_URI, ArgeoNamespace.ROLE_DEFAULT_PREFIX);
}
+ /** The runtime namespace context instance. */
public static NamespaceContext getNamespaceContext() {
return INSTANCE;
}
+ /** The registered prefixes. */
public static Map<String, String> getPrefixes() {
return Collections.unmodifiableNavigableMap(INSTANCE.prefixes);
}
- public synchronized static void register(String namespaceURI, String prefix) {
+ /** Registers a namespace URI / default prefix mapping. */
+ public synchronized static void register(String namespaceURI, String defaultPrefix) {
NavigableMap<String, String> prefixes = INSTANCE.prefixes;
NavigableMap<String, String> namespaces = INSTANCE.namespaces;
- if (prefixes.containsKey(prefix)) {
- String ns = prefixes.get(prefix);
+ if (prefixes.containsKey(defaultPrefix)) {
+ String ns = prefixes.get(defaultPrefix);
if (ns.equals(namespaceURI))
return; // ignore silently
- throw new IllegalStateException("Prefix " + prefix + " is already registered with namespace URI " + ns);
+ throw new IllegalStateException(
+ "Prefix " + defaultPrefix + " is already registered with namespace URI " + ns);
}
if (namespaces.containsKey(namespaceURI)) {
String p = namespaces.get(namespaceURI);
- if (p.equals(prefix))
+ if (p.equals(defaultPrefix))
return; // ignore silently
throw new IllegalStateException("Namespace " + namespaceURI + " is already registered with prefix " + p);
}
- prefixes.put(prefix, namespaceURI);
- namespaces.put(namespaceURI, prefix);
+ prefixes.put(defaultPrefix, namespaceURI);
+ namespaces.put(namespaceURI, defaultPrefix);
}
}
import javax.xml.namespace.QName;
import org.argeo.api.acr.Content;
+import org.argeo.api.acr.CrAttributeType;
import org.argeo.api.acr.CrName;
import org.argeo.api.acr.NamespaceUtils;
import org.argeo.api.acr.spi.ProvidedContent;
if (value == null)
return new ArrayList<>();
if (value instanceof List) {
- if (isDefaultAttrTypeRequested(clss))
+ if (clss.isAssignableFrom(Object.class))
return (List<A>) value;
List<A> res = new ArrayList<>();
List<?> lst = (List<?>) value;
for (Object o : lst) {
- A item = clss.isAssignableFrom(String.class) ? (A) o.toString() : (A) o;
+ A item = CrAttributeType.cast(clss, o).get();
res.add(item);
}
return res;
} else {// singleton
-// try {
- A res = (A) value;
+ A res = CrAttributeType.cast(clss, value).get();
return Collections.singletonList(res);
-// } catch (ClassCastException e) {
-// return Optional.empty();
-// }
}
}
/*
* UTILITIES
*/
- protected boolean isDefaultAttrTypeRequested(Class<?> clss) {
- // check whether clss is Object.class
- return clss.isAssignableFrom(Object.class);
- }
+// protected boolean isDefaultAttrTypeRequested(Class<?> clss) {
+// // check whether clss is Object.class
+// return clss.isAssignableFrom(Object.class);
+// }
// @Override
// public String toString() {
@Override
public <A> Optional<A> get(QName key, Class<A> clss) {
- return null;
+ return Optional.empty();
}
protected void removeAttr(QName key) {
import org.argeo.api.acr.spi.ContentProvider;
import org.argeo.api.acr.spi.ProvidedContent;
import org.argeo.api.acr.spi.ProvidedSession;
-import org.argeo.api.cms.CmsLog;
import org.argeo.cms.acr.AbstractContent;
import org.argeo.cms.acr.ContentUtils;
import org.argeo.cms.util.FsUtils;
/** Content persisted as a filesystem {@link Path}. */
public class FsContent extends AbstractContent implements ProvidedContent {
- private CmsLog log = CmsLog.getLog(FsContent.class);
+// private CmsLog log = CmsLog.getLog(FsContent.class);
final static String USER_ = "user:";
String[] arr = str.split("\n");
if (arr.length == 1) {
- if (clss.isAssignableFrom(String.class)) {
- res = (A) arr[0];
- } else {
- res = (A) CrAttributeType.parse(arr[0]);
- }
+// if (clss.isAssignableFrom(String.class)) {
+// res = (A) arr[0];
+// } else {
+// res = (A) CrAttributeType.parse(arr[0]);
+// }
+// if (isDefaultAttrTypeRequested(clss))
+// return Optional.of((A) CrAttributeType.parse(str));
+ return CrAttributeType.cast(clss, str);
+
} else {
List<Object> lst = new ArrayList<>();
for (String s : arr) {
}
}
if (res == null) {
- if (isDefaultAttrTypeRequested(clss))
- return Optional.of((A) CrAttributeType.parse(value.toString()));
- if (clss.isAssignableFrom(value.getClass()))
- return Optional.of((A) value);
- if (clss.isAssignableFrom(String.class))
- return Optional.of((A) value.toString());
- log.warn("Cannot interpret " + key + " in " + this);
- return Optional.empty();
+// if (isDefaultAttrTypeRequested(clss))
+// return Optional.of((A) CrAttributeType.parse(value.toString()));
+ return CrAttributeType.cast(clss, value);
+// if (clss.isAssignableFrom(value.getClass()))
+// return Optional.of((A) value);
+// if (clss.isAssignableFrom(String.class))
+// return Optional.of((A) value.toString());
+// log.warn("Cannot interpret " + key + " in " + this);
+// return Optional.empty();
// try {
// res = (A) value;
// } catch (ClassCastException e) {
@Override
public List<QName> getContentClasses() {
- List<QName> res = new ArrayList<>();
- List<String> value = getMultiple(DName.resourcetype.qName(), String.class);
- for (String s : value) {
- QName name = NamespaceUtils.parsePrefixedName(provider, s);
- res.add(name);
- }
+// List<QName> res = new ArrayList<>();
+// List<String> value = getMultiple(DName.resourcetype.qName(), String.class);
+// for (String s : value) {
+// QName name = NamespaceUtils.parsePrefixedName(provider, s);
+// res.add(name);
+// }
+ List<QName> res = getMultiple(DName.resourcetype.qName(), QName.class);
if (Files.isDirectory(path))
res.add(DName.collection.qName());
return res;
import org.argeo.api.acr.Content;
import org.argeo.api.acr.ContentName;
+import org.argeo.api.acr.CrAttributeType;
import org.argeo.api.acr.CrName;
import org.argeo.api.acr.spi.ProvidedContent;
import org.argeo.api.acr.spi.ProvidedSession;
return result;
}
- @SuppressWarnings("unchecked")
+// @SuppressWarnings("unchecked")
@Override
public <A> Optional<A> get(QName key, Class<A> clss) {
String namespaceUriOrNull = XMLConstants.NULL_NS_URI.equals(key.getNamespaceURI()) ? null
: key.getNamespaceURI();
if (element.hasAttributeNS(namespaceUriOrNull, key.getLocalPart())) {
String value = element.getAttributeNS(namespaceUriOrNull, key.getLocalPart());
- if (clss.isAssignableFrom(String.class))
- return Optional.of((A) value);
- else
- return Optional.empty();
+// if (isDefaultAttrTypeRequested(clss))
+// return Optional.of((A) CrAttributeType.parse(value));
+ return CrAttributeType.cast(clss, value);
} else
return Optional.empty();
}
projects / lgpl / argeo-commons.git / commitdiff