Update license headers

[lgpl/argeo-commons.git] / eclipse / runtime / org.argeo.eclipse.ui.jcr / src / main / java / org / argeo / eclipse / ui / jcr / AbstractNodeContentProvider.java

diff --git a/eclipse/runtime/org.argeo.eclipse.ui.jcr/src/main/java/org/argeo/eclipse/ui/jcr/AbstractNodeContentProvider.java b/eclipse/runtime/org.argeo.eclipse.ui.jcr/src/main/java/org/argeo/eclipse/ui/jcr/AbstractNodeContentProvider.java
index a8d07ad67211a6969ab38a2839d429792dba3f36..85f487bb2d0d2c9e7c6d817e084813cd409e7298 100644 (file)
--- a/eclipse/runtime/org.argeo.eclipse.ui.jcr/src/main/java/org/argeo/eclipse/ui/jcr/AbstractNodeContentProvider.java
+++ b/eclipse/runtime/org.argeo.eclipse.ui.jcr/src/main/java/org/argeo/eclipse/ui/jcr/AbstractNodeContentProvider.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.argeo.eclipse.ui.jcr;
 
 import java.util.ArrayList;
@@ -8,12 +23,17 @@ import javax.jcr.NodeIterator;
 import javax.jcr.RepositoryException;
 import javax.jcr.Session;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.argeo.ArgeoException;
 import org.argeo.eclipse.ui.AbstractTreeContentProvider;
 
 /** Canonic implementation of tree content provider manipulating JCR nodes. */
 public abstract class AbstractNodeContentProvider extends
                AbstractTreeContentProvider {
+       private final static Log log = LogFactory
+                       .getLog(AbstractNodeContentProvider.class);
+
        private Session session;
 
        public AbstractNodeContentProvider(Session session) {
@@ -31,19 +51,54 @@ public abstract class AbstractNodeContentProvider extends
 
        @Override
        public Object[] getChildren(Object element) {
+               Object[] children;
                if (element instanceof Node) {
                        try {
-                               List<Node> nodes = new ArrayList<Node>();
-                               for (NodeIterator nit = ((Node) element).getNodes(); nit
-                                               .hasNext();)
-                                       nodes.add(nit.nextNode());
-                               return nodes.toArray();
+                               Node node = (Node) element;
+                               children = getChildren(node);
                        } catch (RepositoryException e) {
                                throw new ArgeoException("Cannot get children of " + element, e);
                        }
+               } else if (element instanceof WrappedNode) {
+                       WrappedNode wrappedNode = (WrappedNode) element;
+                       try {
+                               children = getChildren(wrappedNode.getNode());
+                       } catch (RepositoryException e) {
+                               throw new ArgeoException("Cannot get children of "
+                                               + wrappedNode, e);
+                       }
+               } else if (element instanceof NodesWrapper) {
+                       NodesWrapper node = (NodesWrapper) element;
+                       children = node.getChildren();
                } else {
-                       return super.getChildren(element);
+                       children = super.getChildren(element);
                }
+
+               children = sort(element, children);
+               return children;
+       }
+
+       /** Do not sort by default. To be overidden to provide custom sort. */
+       protected Object[] sort(Object parent, Object[] children) {
+               return children;
+       }
+
+       /**
+        * To be overridden in order to filter out some nodes. Does nothing by
+        * default. The provided list is a temporary one and can thus be modified
+        * directly . (e.g. via an iterator)
+        */
+       protected List<Node> filterChildren(List<Node> children)
+                       throws RepositoryException {
+               return children;
+       }
+
+       protected Object[] getChildren(Node node) throws RepositoryException {
+               List<Node> nodes = new ArrayList<Node>();
+               for (NodeIterator nit = node.getNodes(); nit.hasNext();)
+                       nodes.add(nit.nextNode());
+               nodes = filterChildren(nodes);
+               return nodes.toArray();
        }
 
        @Override
@@ -57,22 +112,36 @@ public abstract class AbstractNodeContentProvider extends
                                else
                                        return node.getParent();
                        } catch (RepositoryException e) {
-                               throw new ArgeoException("Cannot get parent of " + element, e);
+                               log.warn("Cannot get parent of " + element + ": " + e);
+                               return null;
                        }
+               } else if (element instanceof WrappedNode) {
+                       WrappedNode wrappedNode = (WrappedNode) element;
+                       return wrappedNode.getParent();
+               } else if (element instanceof NodesWrapper) {
+                       NodesWrapper nodesWrapper = (NodesWrapper) element;
+                       return this.getParent(nodesWrapper.getNode());
                }
                return super.getParent(element);
        }
 
        @Override
        public boolean hasChildren(Object element) {
-               if (element instanceof Node) {
-                       Node node = (Node) element;
-                       try {
+               try {
+                       if (element instanceof Node) {
+                               Node node = (Node) element;
                                return node.hasNodes();
-                       } catch (RepositoryException e) {
-                               throw new ArgeoException("Cannot check whether " + element
-                                               + " has children", e);
+                       } else if (element instanceof WrappedNode) {
+                               WrappedNode wrappedNode = (WrappedNode) element;
+                               return wrappedNode.getNode().hasNodes();
+                       } else if (element instanceof NodesWrapper) {
+                               NodesWrapper nodesWrapper = (NodesWrapper) element;
+                               return nodesWrapper.hasChildren();
                        }
+
+               } catch (RepositoryException e) {
+                       throw new ArgeoException("Cannot check whether " + element
+                                       + " has children", e);
                }
                return super.hasChildren(element);
        }