eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/derivate/DerivateContentProvider.java

   1 package eu.etaxonomy.taxeditor.editor.view.derivate;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collections;
   5 import java.util.LinkedHashSet;
   6 import java.util.List;
   7 import java.util.Set;
   8
   9 import org.eclipse.jface.viewers.ITreeContentProvider;
  10 import org.eclipse.jface.viewers.TreeNode;
  11 import org.eclipse.jface.viewers.Viewer;
  12
  13 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  14 import eu.etaxonomy.cdm.model.molecular.Sequence;
  15 import eu.etaxonomy.cdm.model.molecular.SingleRead;
  16 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
  17 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  18 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  19 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
  20 import eu.etaxonomy.taxeditor.editor.EditorUtil;
  21
  22 public class DerivateContentProvider implements ITreeContentProvider {
  23
  24         @Override
  25         public void dispose() {
  26                 // TODO Auto-generated method stub
  27
  28         }
  29
  30         @Override
  31         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  32         }
  33
  34         @Override
  35         public Object[] getElements(Object inputElement) {
  36             SpecimenOrObservationBase specimen = null;
  37             if(inputElement instanceof DerivateViewEditorInput){
  38                 specimen = ((DerivateViewEditorInput) inputElement).getDerivate();
  39             }
  40
  41             specimen = EditorUtil.getTopMostDerivate(specimen);
  42
  43             if(specimen!=null){
  44                 //show topmost element in the derivate hierarchy if no field unit was found
  45                 TreeNode node = new TreeNode(specimen);
  46             return Collections.singleton(node).toArray();
  47             }
  48             return null;
  49         }
  50
  51         @Override
  52         public Object[] getChildren(Object element) {
  53             TreeNode currentnode = null;
  54             Object value = null;
  55         if(element instanceof TreeNode){
  56             currentnode = (TreeNode) element;
  57             value = ((TreeNode) element).getValue();
  58         }
  59         Set<Object> children = new LinkedHashSet<Object>();
  60         if(value instanceof DnaSample && ((DnaSample) value).getRecordBasis()==SpecimenOrObservationType.DnaSample){
  61             DnaSample dnaSample = (DnaSample)value;
  62             Set<Sequence> sequences = dnaSample.getSequences();
  63             for (Sequence sequence : sequences) {
  64                 TreeNode node = new TreeNode(sequence);
  65                 node.setParent(currentnode);
  66                 children.add(node);
  67             }
  68             return children.toArray();
  69         }
  70         else if(value instanceof Sequence){
  71             Set<SingleRead> singleReads = ((Sequence) value).getSingleReads();
  72             for(SingleRead singleRead:singleReads){
  73                 TreeNode node = new TreeNode(singleRead);
  74                 node.setParent(currentnode);
  75                 children.add(node);
  76             }
  77             return children.toArray();
  78         }
  79         else if(value instanceof SpecimenOrObservationBase){
  80                 List<DerivedUnit> derivates = getDerivates((SpecimenOrObservationBase<?>) value);
  81                 for (DerivedUnit derivedUnit:derivates) {
  82                 TreeNode node = new TreeNode(derivedUnit);
  83                 node.setParent(currentnode);
  84                 children.add(node);
  85             }
  86             return children.toArray();
  87             }
  88             return null;
  89         }
  90
  91         @Override
  92         public Object getParent(Object element) {
  93         if(element instanceof TreeNode){
  94             return ((TreeNode) element).getParent();
  95         }
  96                 return null;
  97         }
  98
  99         @Override
 100         public boolean hasChildren(Object element) {
 101         if(element instanceof TreeNode){
 102             element = ((TreeNode) element).getValue();
 103         }
 104
 105         if(element instanceof DnaSample && ((DnaSample) element).getRecordBasis()==SpecimenOrObservationType.DnaSample){
 106             DnaSample dnaSample = (DnaSample)element;
 107             if(!dnaSample.getSequences().isEmpty()){// || !dnaSample.getAmplifications().isEmpty()){
 108                 return true;
 109             }
 110         }
 111         else if(element instanceof Sequence){
 112             return !((Sequence)element).getSingleReads().isEmpty();
 113         }
 114         else if(element instanceof SpecimenOrObservationBase){
 115                 SpecimenOrObservationBase specimenOrObservation = (SpecimenOrObservationBase)element;
 116                 for(DerivationEvent event:(Set<DerivationEvent>)specimenOrObservation.getDerivationEvents()){
 117                     if(!event.getDerivatives().isEmpty()){
 118                         return true;
 119                     }
 120                 }
 121             }
 122                 return false;
 123         }
 124
 125         private List<DerivedUnit> getDerivates(SpecimenOrObservationBase specimenOrObservation){
 126             List<DerivedUnit> derivates = new ArrayList<DerivedUnit>();
 127             for(DerivationEvent derivationEvent:(Set<DerivationEvent>)specimenOrObservation.getDerivationEvents()){
 128                 derivates.addAll(derivationEvent.getDerivatives());
 129             }
 130             return derivates;
 131         }
 132
 133 }