taxeditor-editor/src/main/java/eu/etaxonomy/taxeditor/editor/name/ContainerFactory.java

   1 /**
   2  *
   3  */
   4 package eu.etaxonomy.taxeditor.editor.name;
   5
   6 import java.util.ArrayList;
   7 import java.util.HashSet;
   8 import java.util.List;
   9 import java.util.Map;
  10 import java.util.Set;
  11
  12 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  13 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
  14 import eu.etaxonomy.cdm.model.taxon.Synonym;
  15 import eu.etaxonomy.cdm.model.taxon.Taxon;
  16 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  17 import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
  18 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  19
  20 /**
  21  * <p>ContainerFactory class.</p>
  22  *
  23  * @author n.hoffmann
  24  * @version $Id: $
  25  */
  26 public class ContainerFactory {
  27
  28         /** Constant <code>ACCEPTED=1</code> */
  29         public static final int ACCEPTED = 1;
  30         /** Constant <code>SYNONYM=2</code> */
  31         public static final int SYNONYM = 2;
  32         /** Constant <code>MISAPPLICATION=3</code> */
  33         public static final int MISAPPLICATION = 3;
  34         /** Constant <code>CONCEPT=4</code> */
  35         public static final int CONCEPT = 4;
  36
  37         private static ContainerFactory instance = new ContainerFactory();
  38
  39         private ContainerFactory(){}
  40
  41         /**
  42          * <p>Getter for the field <code>instance</code>.</p>
  43          *
  44          * @return a {@link eu.etaxonomy.taxeditor.editor.name.ContainerFactory} object.
  45          */
  46         public static synchronized ContainerFactory getInstance(){
  47                 return instance;
  48         }
  49
  50         /**
  51          * <p>createAcceptedTaxonsHomotypicGroup</p>
  52          *
  53          * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
  54          */
  55         public void createAcceptedTaxonsHomotypicGroup(TaxonNameEditor taxonNameEditor) {
  56                 Taxon taxon = taxonNameEditor.getTaxon();
  57
  58                 // Draw homotypic group synonyms
  59                 HomotypicalGroup homotypicGroup = (HomotypicalGroup) HibernateProxyHelper.deproxy(taxon.getHomotypicGroup());
  60                 List<Synonym> homotypicSynonyms = homotypicGroup.getSynonymsInGroup(taxon.getSec());
  61
  62                 HomotypicalSynonymGroup group = taxonNameEditor.getHomotypicSynonymGroup();
  63
  64                 // check if the taxon has changed
  65                 if(group != null && ! taxon.getHomotypicGroup().equals(group.getGroup()) ){
  66                         group.removeAllContainers();
  67                         group.clear();
  68                         group = null;
  69                 }
  70
  71                 // first run
  72                 if(group == null){
  73                         HomotypicalSynonymGroup homotypicalSynonymGroup = new HomotypicalSynonymGroup(taxonNameEditor, homotypicGroup);
  74                         taxonNameEditor.setHomotypicSynonymGroup(homotypicalSynonymGroup);
  75                         AcceptedNameContainer acceptedNameContainer = new AcceptedNameContainer(taxonNameEditor, homotypicalSynonymGroup);
  76
  77                         taxonNameEditor.setAcceptedNameContainer(acceptedNameContainer);
  78                         for(Synonym synonym : homotypicSynonyms){
  79                                 createContainerFactoryMethod(SYNONYM, homotypicalSynonymGroup, synonym, taxonNameEditor);
  80                         }
  81                 }
  82                 // subsequent runs
  83                 else{
  84                         fillGroup(group, homotypicSynonyms, ACCEPTED, taxonNameEditor);
  85                 }
  86         }
  87
  88         /**
  89          * <p>createHeterotypicSynonymGroups</p>
  90          *
  91          * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
  92          */
  93         public void createHeterotypicSynonymGroups(TaxonNameEditor taxonNameEditor) {
  94                 Taxon taxon = taxonNameEditor.getTaxon();
  95
  96                 List<HomotypicalGroup> homotypicalGroups = taxon.getHeterotypicSynonymyGroups();
  97
  98                 // reatins a reference to the homotypical group widgets
  99                 Map<HomotypicalGroup, HomotypicalSynonymGroup> retainedGroups = taxonNameEditor.getHeterotypicSynonymGroupsMap();
 100
 101                 taxonNameEditor.clearHeterotypicSynonymGroups();
 102
 103                 // iterate over taxas synonymy groups
 104                 for (HomotypicalGroup homotypicalGroup : homotypicalGroups) {
 105                         HomotypicalGroup homotypicalGroupDeproxied = (HomotypicalGroup) HibernateProxyHelper.deproxy(homotypicalGroup);
 106
 107                         HomotypicalSynonymGroup group;
 108                         if(retainedGroups.containsKey(homotypicalGroupDeproxied)){
 109                                 group = retainedGroups.get(homotypicalGroupDeproxied);
 110                                 retainedGroups.remove(homotypicalGroupDeproxied);
 111                         }else{
 112                                 group = new HomotypicalSynonymGroup(taxonNameEditor, homotypicalGroupDeproxied);
 113                         }
 114
 115                         createHeterotypicSynonymGroup(taxonNameEditor, group);
 116                         taxonNameEditor.addHeterotypicSynonymGroup(group);
 117                 }
 118
 119                 // remove all groups that did not match
 120                 for(AbstractGroup group : retainedGroups.values()){
 121                         group.clear();
 122                 }
 123         }
 124
 125         /**
 126          * <p>createMisapplicationGroup</p>
 127          *
 128          * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
 129          */
 130         public void createMisapplicationGroup(TaxonNameEditor taxonNameEditor) {
 131                 Taxon taxon = taxonNameEditor.getTaxon();
 132
 133                 List<TaxonBase> content = new ArrayList<TaxonBase>(taxon.getMisappliedNames());
 134
 135                 if(content.size() == 0 && taxonNameEditor.getMisappliedGroup() != null){
 136                         taxonNameEditor.getMisappliedGroup().clear();
 137                         taxonNameEditor.setMisapplicationsGroup(null);
 138                 }else{
 139                         AbstractGroup group = getMisappliedGroup(taxonNameEditor);
 140                         fillGroup(group, content, MISAPPLICATION, taxonNameEditor);
 141                 }
 142         }
 143
 144         /**
 145          * <p>createConceptGroup</p>
 146          *
 147          * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
 148          */
 149         public void createConceptGroup(TaxonNameEditor taxonNameEditor) {
 150                 Taxon taxon = taxonNameEditor.getTaxon();
 151
 152                 Set<TaxonRelationship> filteredTaxonRelations = new HashSet<TaxonRelationship>();
 153
 154                 for (TaxonRelationship relationship : taxon.getTaxonRelations()) {
 155                         if (! relationship.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) ||
 156                                          relationship.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())) {
 157                                 filteredTaxonRelations.add(relationship);
 158                         }
 159                 }
 160
 161                 if(filteredTaxonRelations.size() == 0 && taxonNameEditor.getConceptGroup() != null){
 162                         taxonNameEditor.getConceptGroup().clear();
 163                         taxonNameEditor.setConceptGroup(null);
 164                 }else{
 165                         ConceptGroup group = getConceptGroup(taxonNameEditor);
 166
 167                         // reatain old container
 168                         List<AbstractGroupedContainer<Taxon>> groupedContainers = group.getGroupedContainers();
 169
 170                         group.removeAllContainers();
 171
 172                         // Draw concept relation elements
 173                         for (TaxonRelationship relationship : filteredTaxonRelations) {
 174                                 ConceptContainer.getNewInstance(group.getNameEditor(), group, relationship);
 175                         }
 176                 }
 177         }
 178
 179
 180         /**
 181          * <p>fillGroup</p>
 182          *
 183          * @param group a {@link eu.etaxonomy.taxeditor.editor.name.AbstractGroup} object.
 184          * @param content a {@link java.util.List} object.
 185          * @param mode a int.
 186          * @param taxonNameEditor
 187          */
 188         public void fillGroup(AbstractGroup group, List<? extends TaxonBase> content, int mode, TaxonNameEditor taxonNameEditor){
 189                 if(content == null || (mode != ACCEPTED && content.size() == 0)){
 190                         return;
 191                 }
 192
 193                 AbstractGroupedContainer[] retainedContainers = (AbstractGroupedContainer[]) group.getGroupedContainers().toArray(new AbstractGroupedContainer[0]);
 194
 195                 group.clearContainers();
 196
 197                 if(retainedContainers.length > 0 && retainedContainers[0] instanceof AcceptedNameContainer){
 198                         group.add(retainedContainers[0]);
 199                         retainedContainers[0] = null;
 200                 }
 201
 202                 for(TaxonBase taxonBase : content){
 203                         AbstractGroupedContainer existingContainer = null;
 204                         int i = 0;
 205                         for(AbstractGroupedContainer container : retainedContainers){
 206                                 if(container != null && taxonBase.equals(container.getData())){
 207                                         existingContainer = container;
 208                                         retainedContainers[i] = null;
 209                                 }
 210                                 i++;
 211                         }
 212                         if(existingContainer != null){
 213                                 group.add(existingContainer);
 214                         }else{
 215                                 createContainerFactoryMethod(mode == ACCEPTED ? SYNONYM : mode, group, taxonBase, taxonNameEditor);
 216                         }
 217                 }
 218
 219                 // delete all container that were not used
 220                 for(AbstractGroupedContainer container : retainedContainers){
 221                         if(container != null){
 222                                 group.deleteContainer(container);
 223                         }
 224                 }
 225         }
 226
 227         /**
 228          * <p>createContainerFactoryMethod</p>
 229          *
 230          * @param mode a int.
 231          * @param group a {@link eu.etaxonomy.taxeditor.editor.name.AbstractGroup} object.
 232          * @param taxonBase a {@link eu.etaxonomy.cdm.model.taxon.TaxonBase} object.
 233          * @param taxonNameEditor
 234          * @return a {@link eu.etaxonomy.taxeditor.editor.name.AbstractGroupedContainer} object.
 235          */
 236         public AbstractGroupedContainer createContainerFactoryMethod(int mode, AbstractGroup group, TaxonBase taxonBase, TaxonNameEditor taxonNameEditor){
 237                 AbstractGroupedContainer container = null;
 238
 239                 switch(mode){
 240                 case ACCEPTED:
 241                         container =  new AcceptedNameContainer(group.getNameEditor(), group);
 242                         break;
 243                 case SYNONYM:
 244                         container =  new SynonymContainer(group.getNameEditor(), group, (Synonym) taxonBase);
 245                         break;
 246                 case MISAPPLICATION:
 247                         container =  new MisapplicationContainer(group.getNameEditor(), group, (Taxon) taxonBase);
 248                         break;
 249                 case CONCEPT:
 250                         container =  null;
 251                 }
 252
 253                 taxonNameEditor.getManagedForm().addPart(container);
 254
 255                 return container;
 256         }
 257
 258         /**
 259          * <p>createHeterotypicSynonymGroup</p>
 260          *
 261          * @param taxonNameEditor a {@link eu.etaxonomy.taxeditor.editor.name.TaxonNameEditor} object.
 262          * @param group a {@link eu.etaxonomy.taxeditor.editor.name.HomotypicalSynonymGroup} object.
 263          */
 264         public void createHeterotypicSynonymGroup(TaxonNameEditor taxonNameEditor, HomotypicalSynonymGroup group) {
 265                 Taxon taxon = taxonNameEditor.getTaxon();
 266
 267                 List<AbstractGroupedContainer<Synonym>> groupedContainers = group.getGroupedContainers();
 268
 269                 List<Synonym> heterotypicSynonyms = group.getGroup().getSynonymsInGroup(taxon.getSec());
 270
 271                 fillGroup(group, heterotypicSynonyms, SYNONYM, taxonNameEditor);
 272         }
 273
 274
 275         private MisappliedGroup getMisappliedGroup(TaxonNameEditor editor) {
 276                 if(editor.getMisappliedGroup() == null){
 277                         // Create the group composite
 278                         editor.setMisapplicationsGroup(new MisappliedGroup(editor));
 279                 }
 280
 281                 MisappliedGroup misappliedGroup = editor.getMisappliedGroup();
 282
 283                 // Put the group composite before concept group composite, if any
 284                 if (editor.getConceptGroup() != null) {
 285                         editor.getMisappliedGroup().getControl().moveAbove(editor.getConceptGroup().getControl());
 286                 }
 287
 288                 return misappliedGroup;
 289         }
 290
 291
 292         private ConceptGroup getConceptGroup(TaxonNameEditor editor) {
 293                 if(editor.getConceptGroup() == null){
 294                         // Create the group composite
 295                         editor.setConceptGroup(new ConceptGroup(editor));
 296                 }
 297
 298                 ConceptGroup conceptGroup = editor.getConceptGroup();
 299
 300                 // Put the group composite after misapplied group composite, if any
 301                 if (editor.getMisappliedGroup() != null) {
 302                         editor.getConceptGroup().getControl().moveBelow(editor.getMisappliedGroup().getControl());
 303                 }
 304
 305                 return conceptGroup;
 306
 307         }
 308 }