/ - Diff - EDIT - EDIT Project Management

« Previous | Next »

Revision a50e3be7

Added by Andreas Kohlbecker almost 7 years ago

ID a50e3be7588819c83fdb89485f1515692682063b
Parent b0775553
Child 79295d9d

ref #6719 introducing TypeDesignationWorkingSet with string representation

         private Collection<TypeDesignationBase> typeDesignations;
         /**
          * Groups the EntityReferences for each of the TypeDesignatinos by the according TypeDesignationStatus.
          * Groups the EntityReferences for each of the TypeDesignations by the according TypeDesignationStatus.
          * The TypeDesignationStatusBase keys are already ordered by the term order defined in the vocabulary.
          */
         private LinkedHashMap<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> orderedByTypesByBaseEntity;
         private LinkedHashMap<TypedEntityReference, TypeDesignationWorkingSet> orderedByTypesByBaseEntity;
         private EntityReference typifiedName;
-...
          */
         public TypeDesignationConverter(Collection<TypeDesignationBase> typeDesignations) throws RegistrationValidationException {
             this.typeDesignations = typeDesignations;
             Map<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> byBaseEntityByTypeStatus = new HashMap<>();
             Map<TypedEntityReference, TypeDesignationWorkingSet> byBaseEntityByTypeStatus = new HashMap<>();
             typeDesignations.forEach(td -> mapTypeDesignation(byBaseEntityByTypeStatus, td));
             orderedByTypesByBaseEntity = orderByTypeByBaseEntity(byBaseEntityByTypeStatus);
             this.typifiedName = findTypifiedName();
+        }
         private void mapTypeDesignation(Map<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> byBaseEntityByTypeStatus,
         private void mapTypeDesignation(Map<TypedEntityReference, TypeDesignationWorkingSet> byBaseEntityByTypeStatus,
                 TypeDesignationBase<?> td){
             TypeDesignationStatusBase<?> status = td.getTypeStatus();
-...
             EntityReference typeDesignationEntityReference = new EntityReference(td.getId(), stringify(td));
             Map<TypeDesignationStatusBase<?>, Collection<EntityReference>> stringsOrderdByType;
             TypeDesignationWorkingSet typedesignationWorkingSet;
             if(!byBaseEntityByTypeStatus.containsKey(baseEntityReference)){
                 byBaseEntityByTypeStatus.put(baseEntityReference, new LinkedHashMap<>());
                 byBaseEntityByTypeStatus.put(baseEntityReference, new TypeDesignationWorkingSet());
+            }
             stringsOrderdByType = byBaseEntityByTypeStatus.get(baseEntityReference);
             // the cdm ordered term bases are ordered inverse, fixing this for here
             if(status == null){
                 status = SpecimenTypeDesignationStatus.TYPE();
+            }
             if(!stringsOrderdByType.containsKey(status)){
                 stringsOrderdByType.put(status, new ArrayList<EntityReference>());
+            }
             stringsOrderdByType.get(status).add(typeDesignationEntityReference);
             typedesignationWorkingSet = byBaseEntityByTypeStatus.get(baseEntityReference);
             typedesignationWorkingSet.insert(status, typeDesignationEntityReference);
+        }
         /**
-...
+        }
         private LinkedHashMap<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> orderByTypeByBaseEntity(
                 Map<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> stringsByTypeByBaseEntity){
         private LinkedHashMap<TypedEntityReference, TypeDesignationWorkingSet> orderByTypeByBaseEntity(
                 Map<TypedEntityReference, TypeDesignationWorkingSet> stringsByTypeByBaseEntity){
            // order the FieldUnit TypeName keys
            List<TypedEntityReference> baseEntityKeyList = new LinkedList<>(stringsByTypeByBaseEntity.keySet());
-...
             }});
            // new LinkedHashMap for the ordered FieldUnitOrTypeName keys
            LinkedHashMap<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> stringsOrderedbyBaseEntityOrderdByType = new LinkedHashMap<>(stringsByTypeByBaseEntity.size());
            LinkedHashMap<TypedEntityReference, TypeDesignationWorkingSet> stringsOrderedbyBaseEntityOrderdByType = new LinkedHashMap<>(stringsByTypeByBaseEntity.size());
            for(TypedEntityReference baseEntityRef : baseEntityKeyList){
                Map<TypeDesignationStatusBase<?>, Collection<EntityReference>> stringsByType = stringsByTypeByBaseEntity.get(baseEntityRef);
                TypeDesignationWorkingSet typeDesignationWorkingSet = stringsByTypeByBaseEntity.get(baseEntityRef);
                // order the TypeDesignationStatusBase keys
                 List<TypeDesignationStatusBase<?>> keyList = new LinkedList<>(stringsByType.keySet());
                 List<TypeDesignationStatusBase<?>> keyList = new LinkedList<>(typeDesignationWorkingSet.keySet());
                 Collections.sort(keyList, new Comparator<TypeDesignationStatusBase>() {
                     @Override
                     public int compare(TypeDesignationStatusBase o1, TypeDesignationStatusBase o2) {
-...
+                    }
                 });
                 // new LinkedHashMap for the ordered TypeDesignationStatusBase keys
                 LinkedHashMap<TypeDesignationStatusBase<?>, Collection<EntityReference>> orderedStringsByOrderedTypes = new LinkedHashMap<>();
                 keyList.forEach(key -> orderedStringsByOrderedTypes.put(key, stringsByType.get(key)));
                 TypeDesignationWorkingSet orderedStringsByOrderedTypes = new TypeDesignationWorkingSet();
                 keyList.forEach(key -> orderedStringsByOrderedTypes.put(key, typeDesignationWorkingSet.get(key)));
                 stringsOrderedbyBaseEntityOrderdByType.put(baseEntityRef, orderedStringsByOrderedTypes);
+           }
-...
         public TypeDesignationConverter buildString(){
             if(finalString == null){
                 StringBuilder sb = new StringBuilder();
                 finalString = "";
                 if(getTypifiedNameCache() != null){
                     sb.append(getTypifiedNameCache()).append(" ");
                     finalString += getTypifiedNameCache() + " ";
+                }
                 int typeCount = 0;
                 for(TypedEntityReference baseEntityRef : orderedByTypesByBaseEntity.keySet()) {
                     StringBuilder sb = new StringBuilder();
                     if(typeCount++ > 0){
                         sb.append(TYPE_SEPARATOR);
+                    }
-...
                     if(!baseEntityRef.getLabel().isEmpty()){
                         sb.append(baseEntityRef.getLabel()).append(" ");
+                    }
                     Map<TypeDesignationStatusBase<?>, Collection<EntityReference>> orderedRepresentations = orderedByTypesByBaseEntity.get(baseEntityRef);
                     TypeDesignationWorkingSet typeDesignationWorkingSet = orderedByTypesByBaseEntity.get(baseEntityRef);
                     if(!isNameTypeDesignation ){
                         sb.append("(");
+                    }
                     int typeStatusCount = 0;
                     for(TypeDesignationStatusBase<?> typeStatus : orderedRepresentations.keySet()) {
                     for(TypeDesignationStatusBase<?> typeStatus : typeDesignationWorkingSet.keySet()) {
                         if(typeStatusCount++  > 0){
                             sb.append(TYPE_STATUS_SEPARATOR);
+                        }
                         boolean isPlural = orderedRepresentations.get(typeStatus).size() > 1;
                         boolean isPlural = typeDesignationWorkingSet.get(typeStatus).size() > 1;
                         sb.append(typeStatus.getLabel());
                         if(isPlural){
                             sb.append("s: ");
-...
                             sb.append(", ");
+                        }
                         int typeDesignationCount = 0;
                         for(EntityReference typeDesignationEntityReference : orderedRepresentations.get(typeStatus)) {
                         for(EntityReference typeDesignationEntityReference : typeDesignationWorkingSet.get(typeStatus)) {
                             if(typeDesignationCount++  > 0){
                                 sb.append(TYPE_DESIGNATION_SEPARATOR);
+                            }
                             sb.append(typeDesignationEntityReference.getLabel());
                         };
                     };
+                        }
+                    }
                     if(!isNameTypeDesignation ){
                         sb.append(")");
+                    }
                 };
                     typeDesignationWorkingSet.setRepresentation(sb.toString());
                     finalString += typeDesignationWorkingSet.getRepresentation();
+                }
                 finalString  = sb.toString();
+            }
             return this;
+        }
-...
             return typeDesignations;
+        }
         public LinkedHashMap<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> getOrderedTypeDesignations() {
         public LinkedHashMap<TypedEntityReference, TypeDesignationWorkingSet> getOrderedTypeDesignations() {
             return orderedByTypesByBaseEntity;
+        }
-...
             return null;
+        }
         public String print() {
             return finalString;
+        }
     /**
+     *
      * @author a.kohlbecker
      * @since Jun 12, 2017
+     *
      */
         public class FieldUnitOrTypeName {
         /**
          * Groups the EntityReferences for TypeDesignations by the according TypeDesignationStatus.
          * The TypeDesignationStatusBase keys can be ordered by the term order defined in the vocabulary.
          */
         public class TypeDesignationWorkingSet extends LinkedHashMap<TypeDesignationStatusBase<?>, Collection<EntityReference>> {
             FieldUnit fieldUnit = null;
             String workingSetRepresentation = null;
             TaxonName typeName = null;
             /**
              * @param fieldUnit
              * @param typeName
              */
             private FieldUnitOrTypeName(FieldUnit fieldUnit, TaxonName typeName) {
                 this.fieldUnit = fieldUnit;
                 this.typeName = typeName;
                 if(fieldUnit != null && typeName != null){
                     throw new RuntimeException("FieldUnitOrTypeName must not contain two non null fields");
+                }
             private static final long serialVersionUID = -1329007606500890729L;
                 if(fieldUnit == null && typeName == null){
                     throw new NullPointerException("FieldUnitOrTypeName must not contain two null fields");
+                }
+            }
             /**
              * @return the fieldUnit
              */
             public FieldUnit getFieldUnit() {
                 return fieldUnit;
             public List<EntityReference> getTypeDesignations() {
                 List<EntityReference> typeDesignations = new ArrayList<>();
                 this.values().forEach(typeDesignationReferences -> typeDesignationReferences.forEach(td -> typeDesignations.add(td)));
                 return typeDesignations;
+            }
             /**
              * @return the typeName
              * @param status
              * @param typeDesignationEntityReference
              */
             public TaxonName getTypeName() {
                 return typeName;
+            }
             public void insert(TypeDesignationStatusBase<?> status, EntityReference typeDesignationEntityReference) {
             /**
              * @return the fieldUnit
              */
             public boolean isFieldUnit() {
                 return fieldUnit != null;
+            }
                 if(status == null){
                     status = SpecimenTypeDesignationStatus.TYPE();
+                }
                 if(!containsKey(status)){
                     put(status, new ArrayList<EntityReference>());
+                }
                 get(status).add(typeDesignationEntityReference);
             /**
              * @return the typeName
              */
             public boolean isTypeName() {
                 return typeName != null;
+            }
             public int getEntitiyId() {
                 if(isFieldUnit()){
                     return fieldUnit.getId();
                 } else {
                     return typeName.getId();
+                }
             public String getRepresentation() {
                 return workingSetRepresentation;
+            }
             /**
              * @return
              */
             public String getTypeLabel() {
                 if(isFieldUnit()){
                     return "Type";
                 } else {
                     return "NameType";
+                }
             public void setRepresentation(String representation){
                 this.workingSetRepresentation = representation;
+            }
             /**
              * @return
              */
             public String getTitleCache() {
                 if(isFieldUnit()){
                     return fieldUnit.getTitleCache();
             @Override
             public String toString(){
                 if(workingSetRepresentation != null){
                     return workingSetRepresentation;
                 } else {
                     return typeName.getTitleCache();
                     return super.toString();
+                }
+            }
             public boolean matches(FieldUnit fieldUnit, TaxonName typeName){
                 boolean fuMatch = this.fieldUnit == null && fieldUnit == null || this.fieldUnit.equals(fieldUnit);
                 boolean nameMatch = this.typeName == null && typeName == null || this.typeName.equals(typeName);
                 return fuMatch && nameMatch;
+            }
+        }
+    }

     import java.util.HashSet;
     import java.util.LinkedHashMap;
     import java.util.List;
     import java.util.Map;
     import java.util.Set;
     import java.util.UUID;
-...
     import eu.etaxonomy.cdm.model.name.Registration;
     import eu.etaxonomy.cdm.model.name.RegistrationStatus;
     import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
     import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;
     import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
     import eu.etaxonomy.cdm.model.reference.IReference;
     import eu.etaxonomy.cdm.vaadin.model.EntityReference;
     import eu.etaxonomy.cdm.vaadin.model.TypedEntityReference;
     import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationConverter;
     import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationConverter.TypeDesignationWorkingSet;
     public class RegistrationDTO{
-...
             return name;
+        }
         public LinkedHashMap<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> getOrderdTypeDesignationEntitiyReferences() {
         public LinkedHashMap<TypedEntityReference, TypeDesignationWorkingSet> getOrderdTypeDesignationEntitiyReferences() {
             return typeDesignationConverter != null ? typeDesignationConverter.getOrderedTypeDesignations() : null;
+        }

     import eu.etaxonomy.cdm.vaadin.CdmVaadinBaseTest;
     import eu.etaxonomy.cdm.vaadin.model.EntityReference;
     import eu.etaxonomy.cdm.vaadin.model.TypedEntityReference;
     import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationConverter.TypeDesignationWorkingSet;
     import eu.etaxonomy.cdm.vaadin.view.registration.RegistrationValidationException;
     /**
-...
             Logger.getLogger(this.getClass()).debug(result);
             assertNotNull(result);
             assertEquals(
                     "Prionus coriatius L. Type: Testland, near Bughausen, A.Kohlbecker 81989, 2017 (Holotype, OHA; Isotypes: BER, KEW); NameType: Unknown type category, Prionus L. Species Platarum; Type: (Isotype, M)"
                     , result
                     );
             LinkedHashMap<TypedEntityReference, Map<TypeDesignationStatusBase<?>, Collection<EntityReference>>> orderedTypeDesignations =
             LinkedHashMap<TypedEntityReference, TypeDesignationWorkingSet> orderedTypeDesignations =
                     typeDesignationConverter.getOrderedTypeDesignations();
             Map<TypeDesignationStatusBase<?>, Collection<EntityReference>> byStatusMap = orderedTypeDesignations.values().iterator().next();
             Iterator<TypeDesignationStatusBase<?>> keyIt = byStatusMap.keySet().iterator();

Also available in: Unified diff

Project

General

Profile

EDIT

Revision a50e3be7

Added by Andreas Kohlbecker almost 7 years ago

Project

General

Profile

EDIT

Revision a50e3be7

Added by Andreas Kohlbecker almost 7 years ago

Related issues