eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/view/derivateSearch/DerivateContentProvider.java

   1 package eu.etaxonomy.taxeditor.view.derivateSearch;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.Comparator;
   6 import java.util.LinkedHashSet;
   7 import java.util.List;
   8 import java.util.Set;
   9 import java.util.TreeSet;
  10
  11 import org.eclipse.jface.viewers.ITreeContentProvider;
  12 import org.eclipse.jface.viewers.TreeNode;
  13 import org.eclipse.jface.viewers.Viewer;
  14
  15 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  16 import eu.etaxonomy.cdm.model.molecular.Sequence;
  17 import eu.etaxonomy.cdm.model.molecular.SingleRead;
  18 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
  19 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  20 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  21 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
  22
  23 public class DerivateContentProvider implements ITreeContentProvider {
  24
  25     private TreeSet<TreeNode> rootNodes;
  26
  27         @Override
  28         public void dispose() {
  29                 // TODO Auto-generated method stub
  30
  31         }
  32
  33         public List<SpecimenOrObservationBase> getRootElements() {
  34             List<SpecimenOrObservationBase> elements = new ArrayList<SpecimenOrObservationBase>();
  35
  36             if(rootNodes != null) {
  37                 for(TreeNode node : rootNodes) {
  38                     elements.add((SpecimenOrObservationBase)node.getValue());
  39                 }
  40             }
  41             return elements;
  42         }
  43
  44         @Override
  45         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  46         }
  47
  48         @Override
  49         public Object[] getElements(Object inputElement) {
  50             rootNodes = new TreeSet<TreeNode>(new TreeNodeComparator());
  51             if(inputElement instanceof Collection){
  52                 for (Object o: (Collection)inputElement) {
  53                     if(o instanceof SpecimenOrObservationBase){
  54                         SpecimenOrObservationBase<?> rootElement = (SpecimenOrObservationBase<?>)o;
  55                         if(rootElement!=null){
  56                             rootNodes.add(new TreeNode(rootElement));
  57                         }
  58                     }
  59             }
  60             }
  61             return rootNodes.toArray();
  62         }
  63
  64         @Override
  65         public Object[] getChildren(Object element) {
  66             TreeNode currentnode = null;
  67             Object value = null;
  68         if(element instanceof TreeNode){
  69             currentnode = (TreeNode) element;
  70             value = ((TreeNode) element).getValue();
  71         }
  72         Set<Object> children = new LinkedHashSet<Object>();
  73         if(value instanceof DnaSample && ((DnaSample) value).getRecordBasis()==SpecimenOrObservationType.DnaSample){
  74             DnaSample dnaSample = (DnaSample)value;
  75             Set<Sequence> sequences = dnaSample.getSequences();
  76             for (Sequence sequence : sequences) {
  77                 TreeNode node = new TreeNode(sequence);
  78                 node.setParent(currentnode);
  79                 children.add(node);
  80             }
  81         }
  82         else if(value instanceof Sequence){
  83             Set<SingleRead> singleReads = ((Sequence) value).getSingleReads();
  84             for(SingleRead singleRead:singleReads){
  85                 TreeNode node = new TreeNode(singleRead);
  86                 node.setParent(currentnode);
  87                 children.add(node);
  88             }
  89             return children.toArray();
  90         }
  91
  92         if(value instanceof SpecimenOrObservationBase){
  93                 List<DerivedUnit> derivates = getDerivates((SpecimenOrObservationBase<?>) value);
  94                 for (DerivedUnit derivedUnit:derivates) {
  95                 TreeNode node = new TreeNode(derivedUnit);
  96                 node.setParent(currentnode);
  97                 children.add(node);
  98             }
  99             return children.toArray();
 100             }
 101             return null;
 102         }
 103
 104         @Override
 105         public Object getParent(Object element) {
 106         if(element instanceof TreeNode){
 107             return ((TreeNode) element).getParent();
 108         }
 109                 return null;
 110         }
 111
 112         @Override
 113         public boolean hasChildren(Object element) {
 114         if(element instanceof TreeNode){
 115             element = ((TreeNode) element).getValue();
 116         }
 117
 118         if(element instanceof DnaSample && ((DnaSample) element).getRecordBasis()==SpecimenOrObservationType.DnaSample){
 119             DnaSample dnaSample = (DnaSample)element;
 120             if(!dnaSample.getSequences().isEmpty()){// || !dnaSample.getAmplifications().isEmpty()){
 121                 return true;
 122             }
 123         }
 124         else if(element instanceof Sequence){
 125             return !((Sequence)element).getSingleReads().isEmpty();
 126         }
 127
 128         if(element instanceof SpecimenOrObservationBase){
 129                 SpecimenOrObservationBase<?> specimenOrObservation = (SpecimenOrObservationBase<?>)element;
 130                 for(DerivationEvent event:specimenOrObservation.getDerivationEvents()){
 131                     if(!event.getDerivatives().isEmpty()){
 132                         return true;
 133                     }
 134                 }
 135             }
 136                 return false;
 137         }
 138
 139         private List<DerivedUnit> getDerivates(SpecimenOrObservationBase<?> specimenOrObservation){
 140             List<DerivedUnit> derivates = new ArrayList<DerivedUnit>();
 141             for(DerivationEvent derivationEvent:specimenOrObservation.getDerivationEvents()){
 142                 derivates.addAll(derivationEvent.getDerivatives());
 143             }
 144             return derivates;
 145         }
 146
 147         private class TreeNodeComparator implements Comparator<TreeNode>{
 148
 149                 @Override
 150                 public int compare(TreeNode o1, TreeNode o2) {
 151                         if(o1!=null && o2==null){
 152                                 return -1;
 153                         }
 154                         else if(o1==null && o2!=null){
 155                                 return 1;
 156                         }
 157                         else if(o1!=null && o2!=null){
 158                                 SpecimenOrObservationBase<?> specimenOrObservation1 = (SpecimenOrObservationBase<?>) o1.getValue();
 159                                 SpecimenOrObservationBase<?> specimenOrObservation2 = (SpecimenOrObservationBase<?>) o2.getValue();
 160                                 return specimenOrObservation1.getTitleCache().compareTo(specimenOrObservation2.getTitleCache());
 161                         }
 162                         return 0;
 163                 }
 164
 165         }
 166
 167 }