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