Work on typing

[lgpl/argeo-commons.git] / org.argeo.cms.jcr / src / org / argeo / cms / jcr / gcr / JcrContent.java

diff --git a/org.argeo.cms.jcr/src/org/argeo/cms/jcr/gcr/JcrContent.java b/org.argeo.cms.jcr/src/org/argeo/cms/jcr/gcr/JcrContent.java
index b136a0105eab82f78fa5d8c269bea4807205a305..af63ead61721ed3296d33d2e31c203367740e024 100644 (file)
--- a/org.argeo.cms.jcr/src/org/argeo/cms/jcr/gcr/JcrContent.java
+++ b/org.argeo.cms.jcr/src/org/argeo/cms/jcr/gcr/JcrContent.java
@@ -2,6 +2,7 @@ package org.argeo.cms.jcr.gcr;
 
 import java.util.Calendar;
 import java.util.Iterator;
+import java.util.Optional;
 
 import javax.jcr.Node;
 import javax.jcr.NodeIterator;
@@ -10,52 +11,58 @@ import javax.jcr.PropertyIterator;
 import javax.jcr.PropertyType;
 import javax.jcr.RepositoryException;
 import javax.jcr.Value;
+import javax.jcr.nodetype.NodeType;
+import javax.xml.namespace.QName;
 
 import org.argeo.api.gcr.Content;
 import org.argeo.api.gcr.spi.AbstractContent;
+import org.argeo.api.gcr.spi.ProvidedSession;
 import org.argeo.jcr.Jcr;
 import org.argeo.jcr.JcrException;
 
 public class JcrContent extends AbstractContent {
-       private JcrContentSession contentSession;
        private Node jcrNode;
 
-       protected JcrContent(JcrContentSession contentSession, Node node) {
-               this.contentSession = contentSession;
+       private JcrContentProvider provider;
+       private ProvidedSession session;
+
+       protected JcrContent(ProvidedSession session, JcrContentProvider provider, Node node) {
+               this.session = session;
+               this.provider = provider;
                this.jcrNode = node;
        }
 
        @Override
-       public String getName() {
-               return Jcr.getName(jcrNode);
+       public QName getName() {
+               return session.parsePrefixedName(Jcr.getName(jcrNode));
        }
 
        @Override
-       public <A> A get(String key, Class<A> clss) {
+       public <A> Optional<A> get(QName key, Class<A> clss) {
                if (isDefaultAttrTypeRequested(clss)) {
-                       return (A) get(jcrNode, key);
+                       return Optional.of((A) get(jcrNode, key.toString()));
                }
-               return (A) Jcr.get(jcrNode, key);
+               return Optional.of((A) Jcr.get(jcrNode, key.toString()));
        }
 
        @Override
        public Iterator<Content> iterator() {
                try {
-                       return new JcrContentIterator(contentSession, jcrNode.getNodes());
+                       return new JcrContentIterator(jcrNode.getNodes());
                } catch (RepositoryException e) {
                        throw new JcrException("Cannot list children of " + jcrNode, e);
                }
        }
 
        @Override
-       protected Iterable<String> keys() {
-               return new Iterable<String>() {
+       protected Iterable<QName> keys() {
+               return new Iterable<QName>() {
 
                        @Override
-                       public Iterator<String> iterator() {
+                       public Iterator<QName> iterator() {
                                try {
                                        PropertyIterator propertyIterator = jcrNode.getProperties();
-                                       return new JcrKeyIterator(contentSession, propertyIterator);
+                                       return new JcrKeyIterator(provider, propertyIterator);
                                } catch (RepositoryException e) {
                                        throw new JcrException("Cannot retrive properties from " + jcrNode, e);
                                }
@@ -93,14 +100,12 @@ public class JcrContent extends AbstractContent {
                }
        }
 
-       static class JcrContentIterator implements Iterator<Content> {
-               private final JcrContentSession contentSession;
+       class JcrContentIterator implements Iterator<Content> {
                private final NodeIterator nodeIterator;
                // we keep track in order to be able to delete it
                private JcrContent current = null;
 
-               protected JcrContentIterator(JcrContentSession contentSession, NodeIterator nodeIterator) {
-                       this.contentSession = contentSession;
+               protected JcrContentIterator(NodeIterator nodeIterator) {
                        this.nodeIterator = nodeIterator;
                }
 
@@ -111,25 +116,66 @@ public class JcrContent extends AbstractContent {
 
                @Override
                public Content next() {
-                       current = new JcrContent(contentSession, nodeIterator.nextNode());
+                       current = new JcrContent(session, provider, nodeIterator.nextNode());
                        return current;
                }
 
                @Override
                public void remove() {
                        if (current != null) {
-                               // current.getJcrNode().remove();
+                               Jcr.remove(current.getJcrNode());
+                       }
+               }
+
+       }
+
+       @Override
+       public Content getParent() {
+               return new JcrContent(session, provider, Jcr.getParent(getJcrNode()));
+       }
+
+       @Override
+       public Content add(QName name, QName... classes) {
+               if (classes.length > 0) {
+                       QName primaryType = classes[0];
+                       Node child = Jcr.addNode(getJcrNode(), name.toString(), primaryType.toString());
+                       for (int i = 1; i < classes.length; i++) {
+                               try {
+                                       child.addMixin(classes[i].toString());
+                               } catch (RepositoryException e) {
+                                       throw new JcrException("Cannot add child to " + getJcrNode(), e);
+                               }
+                       }
+
+               } else {
+                       Jcr.addNode(getJcrNode(), name.toString(), NodeType.NT_UNSTRUCTURED);
+               }
+               return null;
+       }
+
+       @Override
+       public void remove() {
+               Jcr.remove(getJcrNode());
+       }
+
+       @Override
+       protected void removeAttr(QName key) {
+               Property property = Jcr.getProperty(getJcrNode(), key.toString());
+               if (property != null) {
+                       try {
+                               property.remove();
+                       } catch (RepositoryException e) {
+                               throw new JcrException("Cannot remove property " + key + " from " + getJcrNode(), e);
                        }
-                       throw new UnsupportedOperationException();
                }
 
        }
 
-       static class JcrKeyIterator implements Iterator<String> {
-               private final JcrContentSession contentSession;
+       class JcrKeyIterator implements Iterator<QName> {
+               private final JcrContentProvider contentSession;
                private final PropertyIterator propertyIterator;
 
-               protected JcrKeyIterator(JcrContentSession contentSession, PropertyIterator propertyIterator) {
+               protected JcrKeyIterator(JcrContentProvider contentSession, PropertyIterator propertyIterator) {
                        this.contentSession = contentSession;
                        this.propertyIterator = propertyIterator;
                }
@@ -140,12 +186,12 @@ public class JcrContent extends AbstractContent {
                }
 
                @Override
-               public String next() {
+               public QName next() {
                        Property property = null;
                        try {
                                property = propertyIterator.nextProperty();
                                // TODO map standard property names
-                               return property.getName();
+                               return session.parsePrefixedName(property.getName());
                        } catch (RepositoryException e) {
                                throw new JcrException("Cannot retrieve property " + property, null);
                        }