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