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