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.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
  21 public class DerivateContentProvider implements ITreeContentProvider {
  22
  23     List<TreeNode> rootNodes;
  24
  25         @Override
  26         public void dispose() {
  27                 // TODO Auto-generated method stub
  28
  29         }
  30
  31         public List<SpecimenOrObservationBase> getRootElements() {
  32             List<SpecimenOrObservationBase> elements = new ArrayList<SpecimenOrObservationBase>();
  33
  34             if(rootNodes != null) {
  35                 for(TreeNode node : rootNodes) {
  36                     elements.add((SpecimenOrObservationBase)node.getValue());
  37                 }
  38             }
  39             return elements;
  40         }
  41
  42         @Override
  43         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  44         }
  45
  46         @Override
  47         public Object[] getElements(Object inputElement) {
  48             rootNodes = new ArrayList<TreeNode>();
  49             if(inputElement instanceof Collection){
  50                 for (Object o: (Collection)inputElement) {
  51                     if(o instanceof SpecimenOrObservationBase){
  52                         SpecimenOrObservationBase<?> rootElement = (SpecimenOrObservationBase<?>)o;
  53                         if(rootElement!=null){
  54                             rootNodes.add(new TreeNode(rootElement));
  55                         }
  56                     }
  57             }
  58             }
  59             return rootNodes.toArray();
  60         }
  61
  62         @Override
  63         public Object[] getChildren(Object element) {
  64             TreeNode currentnode = null;
  65             Object value = null;
  66         if(element instanceof TreeNode){
  67             currentnode = (TreeNode) element;
  68             value = ((TreeNode) element).getValue();
  69         }
  70         Set<Object> children = new LinkedHashSet<Object>();
  71         if(value instanceof DnaSample && ((DnaSample) value).getRecordBasis()==SpecimenOrObservationType.DnaSample){
  72             DnaSample dnaSample = (DnaSample)value;
  73             Set<Sequence> sequences = dnaSample.getSequences();
  74             for (Sequence sequence : sequences) {
  75                 TreeNode node = new TreeNode(sequence);
  76                 node.setParent(currentnode);
  77                 children.add(node);
  78             }
  79         }
  80         else if(value instanceof Sequence){
  81             Set<SingleRead> singleReads = ((Sequence) value).getSingleReads();
  82             for(SingleRead singleRead:singleReads){
  83                 TreeNode node = new TreeNode(singleRead);
  84                 node.setParent(currentnode);
  85                 children.add(node);
  86             }
  87             return children.toArray();
  88         }
  89
  90         if(value instanceof SpecimenOrObservationBase){
  91                 List<DerivedUnit> derivates = getDerivates((SpecimenOrObservationBase<?>) value);
  92                 for (DerivedUnit derivedUnit:derivates) {
  93                 TreeNode node = new TreeNode(derivedUnit);
  94                 node.setParent(currentnode);
  95                 children.add(node);
  96             }
  97             return children.toArray();
  98             }
  99             return null;
 100         }
 101
 102         @Override
 103         public Object getParent(Object element) {
 104         if(element instanceof TreeNode){
 105             return ((TreeNode) element).getParent();
 106         }
 107                 return null;
 108         }
 109
 110         @Override
 111         public boolean hasChildren(Object element) {
 112         if(element instanceof TreeNode){
 113             element = ((TreeNode) element).getValue();
 114         }
 115
 116         if(element instanceof DnaSample && ((DnaSample) element).getRecordBasis()==SpecimenOrObservationType.DnaSample){
 117             DnaSample dnaSample = (DnaSample)element;
 118             if(!dnaSample.getSequences().isEmpty()){// || !dnaSample.getAmplifications().isEmpty()){
 119                 return true;
 120             }
 121         }
 122         else if(element instanceof Sequence){
 123             return !((Sequence)element).getSingleReads().isEmpty();
 124         }
 125
 126         if(element instanceof SpecimenOrObservationBase){
 127                 SpecimenOrObservationBase<?> specimenOrObservation = (SpecimenOrObservationBase<?>)element;
 128                 for(DerivationEvent event:specimenOrObservation.getDerivationEvents()){
 129                     if(!event.getDerivatives().isEmpty()){
 130                         return true;
 131                     }
 132                 }
 133             }
 134                 return false;
 135         }
 136
 137         private List<DerivedUnit> getDerivates(SpecimenOrObservationBase<?> specimenOrObservation){
 138             List<DerivedUnit> derivates = new ArrayList<DerivedUnit>();
 139             for(DerivationEvent derivationEvent:specimenOrObservation.getDerivationEvents()){
 140                 derivates.addAll(derivationEvent.getDerivatives());
 141             }
 142             return derivates;
 143         }
 144
 145 }