org.argeo.cms.ui/src/org/argeo/eclipse/ui/jcr/AbstractNodeContentProvider.java

   1 package org.argeo.eclipse.ui.jcr;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import javax.jcr.Node;
   7 import javax.jcr.NodeIterator;
   8 import javax.jcr.RepositoryException;
   9 import javax.jcr.Session;
  10
  11 import org.apache.commons.logging.Log;
  12 import org.apache.commons.logging.LogFactory;
  13 import org.argeo.eclipse.ui.AbstractTreeContentProvider;
  14 import org.argeo.eclipse.ui.EclipseUiException;
  15
  16 /** Canonical implementation of tree content provider manipulating JCR nodes. */
  17 public abstract class AbstractNodeContentProvider extends
  18                 AbstractTreeContentProvider {
  19         private static final long serialVersionUID = -4905836490027272569L;
  20
  21         private final static Log log = LogFactory
  22                         .getLog(AbstractNodeContentProvider.class);
  23
  24         private Session session;
  25
  26         public AbstractNodeContentProvider(Session session) {
  27                 this.session = session;
  28         }
  29
  30         /**
  31          * Whether this path is a base path (and thus has no parent). By default it
  32          * returns true if path is '/' (root node)
  33          */
  34         protected Boolean isBasePath(String path) {
  35                 // root node
  36                 return path.equals("/");
  37         }
  38
  39         @Override
  40         public Object[] getChildren(Object element) {
  41                 Object[] children;
  42                 if (element instanceof Node) {
  43                         try {
  44                                 Node node = (Node) element;
  45                                 children = getChildren(node);
  46                         } catch (RepositoryException e) {
  47                                 throw new EclipseUiException("Cannot get children of " + element, e);
  48                         }
  49                 } else if (element instanceof WrappedNode) {
  50                         WrappedNode wrappedNode = (WrappedNode) element;
  51                         try {
  52                                 children = getChildren(wrappedNode.getNode());
  53                         } catch (RepositoryException e) {
  54                                 throw new EclipseUiException("Cannot get children of "
  55                                                 + wrappedNode, e);
  56                         }
  57                 } else if (element instanceof NodesWrapper) {
  58                         NodesWrapper node = (NodesWrapper) element;
  59                         children = node.getChildren();
  60                 } else {
  61                         children = super.getChildren(element);
  62                 }
  63
  64                 children = sort(element, children);
  65                 return children;
  66         }
  67
  68         /** Do not sort by default. To be overidden to provide custom sort. */
  69         protected Object[] sort(Object parent, Object[] children) {
  70                 return children;
  71         }
  72
  73         /**
  74          * To be overridden in order to filter out some nodes. Does nothing by
  75          * default. The provided list is a temporary one and can thus be modified
  76          * directly . (e.g. via an iterator)
  77          */
  78         protected List<Node> filterChildren(List<Node> children)
  79                         throws RepositoryException {
  80                 return children;
  81         }
  82
  83         protected Object[] getChildren(Node node) throws RepositoryException {
  84                 List<Node> nodes = new ArrayList<Node>();
  85                 for (NodeIterator nit = node.getNodes(); nit.hasNext();)
  86                         nodes.add(nit.nextNode());
  87                 nodes = filterChildren(nodes);
  88                 return nodes.toArray();
  89         }
  90
  91         @Override
  92         public Object getParent(Object element) {
  93                 if (element instanceof Node) {
  94                         Node node = (Node) element;
  95                         try {
  96                                 String path = node.getPath();
  97                                 if (isBasePath(path))
  98                                         return null;
  99                                 else
 100                                         return node.getParent();
 101                         } catch (RepositoryException e) {
 102                                 log.warn("Cannot get parent of " + element + ": " + e);
 103                                 return null;
 104                         }
 105                 } else if (element instanceof WrappedNode) {
 106                         WrappedNode wrappedNode = (WrappedNode) element;
 107                         return wrappedNode.getParent();
 108                 } else if (element instanceof NodesWrapper) {
 109                         NodesWrapper nodesWrapper = (NodesWrapper) element;
 110                         return this.getParent(nodesWrapper.getNode());
 111                 }
 112                 return super.getParent(element);
 113         }
 114
 115         @Override
 116         public boolean hasChildren(Object element) {
 117                 try {
 118                         if (element instanceof Node) {
 119                                 Node node = (Node) element;
 120                                 return node.hasNodes();
 121                         } else if (element instanceof WrappedNode) {
 122                                 WrappedNode wrappedNode = (WrappedNode) element;
 123                                 return wrappedNode.getNode().hasNodes();
 124                         } else if (element instanceof NodesWrapper) {
 125                                 NodesWrapper nodesWrapper = (NodesWrapper) element;
 126                                 return nodesWrapper.hasChildren();
 127                         }
 128
 129                 } catch (RepositoryException e) {
 130                         throw new EclipseUiException("Cannot check whether " + element
 131                                         + " has children", e);
 132                 }
 133                 return super.hasChildren(element);
 134         }
 135
 136         public Session getSession() {
 137                 return session;
 138         }
 139 }