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.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 DerivateViewEditorInput){
  39                 Set<UUID> rootUUIDs = ((DerivateViewEditorInput) inputElement).getRootUUIDs();
  40                 for (UUID uuid : rootUUIDs) {
  41                     SpecimenOrObservationBase<?> rootElement = CdmStore.getService(IOccurrenceService.class).load(uuid);
  42                 if(rootElement!=null){
  43                     rootElements.add(new TreeNode(rootElement));
  44                 }
  45             }
  46             }
  47             return rootElements.toArray();
  48         }
  49
  50         @Override
  51         public Object[] getChildren(Object element) {
  52             TreeNode currentnode = null;
  53             Object value = null;
  54         if(element instanceof TreeNode){
  55             currentnode = (TreeNode) element;
  56             value = ((TreeNode) element).getValue();
  57         }
  58         Set<Object> children = new LinkedHashSet<Object>();
  59         if(value instanceof DnaSample && ((DnaSample) value).getRecordBasis()==SpecimenOrObservationType.DnaSample){
  60             DnaSample dnaSample = (DnaSample)value;
  61             Set<Sequence> sequences = dnaSample.getSequences();
  62             for (Sequence sequence : sequences) {
  63                 TreeNode node = new TreeNode(sequence);
  64                 node.setParent(currentnode);
  65                 children.add(node);
  66             }
  67             return children.toArray();
  68         }
  69         else if(value instanceof Sequence){
  70             Set<SingleRead> singleReads = ((Sequence) value).getSingleReads();
  71             for(SingleRead singleRead:singleReads){
  72                 TreeNode node = new TreeNode(singleRead);
  73                 node.setParent(currentnode);
  74                 children.add(node);
  75             }
  76             return children.toArray();
  77         }
  78         else if(value instanceof SpecimenOrObservationBase){
  79                 List<DerivedUnit> derivates = getDerivates((SpecimenOrObservationBase<?>) value);
  80                 for (DerivedUnit derivedUnit:derivates) {
  81                 TreeNode node = new TreeNode(derivedUnit);
  82                 node.setParent(currentnode);
  83                 children.add(node);
  84             }
  85             return children.toArray();
  86             }
  87             return null;
  88         }
  89
  90         @Override
  91         public Object getParent(Object element) {
  92         if(element instanceof TreeNode){
  93             return ((TreeNode) element).getParent();
  94         }
  95                 return null;
  96         }
  97
  98         @Override
  99         public boolean hasChildren(Object element) {
 100         if(element instanceof TreeNode){
 101             element = ((TreeNode) element).getValue();
 102         }
 103
 104         if(element instanceof DnaSample && ((DnaSample) element).getRecordBasis()==SpecimenOrObservationType.DnaSample){
 105             DnaSample dnaSample = (DnaSample)element;
 106             if(!dnaSample.getSequences().isEmpty()){// || !dnaSample.getAmplifications().isEmpty()){
 107                 return true;
 108             }
 109         }
 110         else if(element instanceof Sequence){
 111             return !((Sequence)element).getSingleReads().isEmpty();
 112         }
 113         else if(element instanceof SpecimenOrObservationBase){
 114                 SpecimenOrObservationBase<?> specimenOrObservation = (SpecimenOrObservationBase<?>)element;
 115                 for(DerivationEvent event:specimenOrObservation.getDerivationEvents()){
 116                     if(!event.getDerivatives().isEmpty()){
 117                         return true;
 118                     }
 119                 }
 120             }
 121                 return false;
 122         }
 123
 124         private List<DerivedUnit> getDerivates(SpecimenOrObservationBase<?> specimenOrObservation){
 125             List<DerivedUnit> derivates = new ArrayList<DerivedUnit>();
 126             for(DerivationEvent derivationEvent:specimenOrObservation.getDerivationEvents()){
 127                 derivates.addAll(derivationEvent.getDerivatives());
 128             }
 129             return derivates;
 130         }
 131
 132 }