import eu.etaxonomy.cdm.model.term.TermVocabulary;
/**
- * NOTE: This class was moved here from TypeDesignationWorkingSet to allow to be used
+ * NOTE: This class was moved here from TypeDesignationSet to allow to be used
* in model compare classes.
*
* @author a.kohlbecker
-/**\r
-* Copyright (C) 2009 EDIT\r
-* European Distributed Institute of Taxonomy\r
-* http://www.e-taxonomy.eu\r
-*\r
-* The contents of this file are subject to the Mozilla Public License Version 1.1\r
-* See LICENSE.TXT at the top of this package for the full license terms.\r
-*/\r
-package eu.etaxonomy.cdm.remote.json.processor.value;\r
-\r
-import java.util.Map;\r
-import java.util.Objects;\r
-\r
-import eu.etaxonomy.cdm.api.service.l10n.TermRepresentation_L10n;\r
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet;\r
-import eu.etaxonomy.cdm.model.common.LanguageString;\r
-import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;\r
-import eu.etaxonomy.cdm.ref.TypedEntityReference;\r
-import net.sf.json.JSONObject;\r
-import net.sf.json.JsonConfig;\r
-import net.sf.json.processors.JsonValueProcessor;\r
-\r
-/**\r
- * @author a.kohlbecker\r
- * @since 23.06.2010\r
- *\r
- */\r
-public class MapJSONValueProcessor implements JsonValueProcessor {\r
-\r
-\r
- @Override\r
- public Object processArrayValue(Object value, JsonConfig jsonConfig) {\r
-\r
- if(value instanceof TypeDesignationWorkingSet){\r
- TypeDesignationWorkingSet map = (TypeDesignationWorkingSet)value;\r
- JSONObject json = new JSONObject();\r
- for(TypeDesignationStatusBase<?> key : map.keySet()){\r
- TermRepresentation_L10n term_L10n = new TermRepresentation_L10n(key, false);\r
- String label = Objects.toString(term_L10n.getLabel(), "NULL");\r
- json.element(label, map.get(key), jsonConfig);\r
- }\r
- return json;\r
- } else if(value instanceof Map){\r
- Map<?,?> map= (Map<?,?>)value;\r
- if( ! map.isEmpty()){\r
- JSONObject json = new JSONObject();\r
- if(map.keySet().iterator().next() instanceof TypedEntityReference){\r
- for(Object key : map.keySet()){\r
- json.element(key.toString(), map.get(key), jsonConfig);\r
- }\r
- } else {\r
- for (Object val : map.values()){\r
- if(val instanceof LanguageString){\r
- json.element(((LanguageString)val).getLanguageLabel(), val, jsonConfig);\r
- } else {\r
- return JSONObject.fromObject(value, jsonConfig);\r
- }\r
- }\r
- }\r
- return json;\r
- }\r
- }\r
- return JSONObject.fromObject(value, jsonConfig);\r
- }\r
-\r
- /* (non-Javadoc)\r
- * @see net.sf.json.processors.JsonValueProcessor#processObjectValue(java.lang.String, java.lang.Object, net.sf.json.JsonConfig)\r
- */\r
- @Override\r
- public Object processObjectValue(String key, Object value,\r
- JsonConfig jsonConfig) {\r
- return processArrayValue(value, jsonConfig);\r
- }\r
-\r
-}\r
+/**
+* Copyright (C) 2009 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+package eu.etaxonomy.cdm.remote.json.processor.value;
+
+import java.util.Map;
+import java.util.Objects;
+
+import eu.etaxonomy.cdm.api.service.l10n.TermRepresentation_L10n;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet;
+import eu.etaxonomy.cdm.model.common.LanguageString;
+import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;
+import eu.etaxonomy.cdm.ref.TypedEntityReference;
+import net.sf.json.JSONObject;
+import net.sf.json.JsonConfig;
+import net.sf.json.processors.JsonValueProcessor;
+
+/**
+ * @author a.kohlbecker
+ * @since 23.06.2010
+ *
+ */
+public class MapJSONValueProcessor implements JsonValueProcessor {
+
+
+ @Override
+ public Object processArrayValue(Object value, JsonConfig jsonConfig) {
+
+ if(value instanceof TypeDesignationSet){
+ TypeDesignationSet map = (TypeDesignationSet)value;
+ JSONObject json = new JSONObject();
+ for(TypeDesignationStatusBase<?> key : map.keySet()){
+ TermRepresentation_L10n term_L10n = new TermRepresentation_L10n(key, false);
+ String label = Objects.toString(term_L10n.getLabel(), "NULL");
+ json.element(label, map.get(key), jsonConfig);
+ }
+ return json;
+ } else if(value instanceof Map){
+ Map<?,?> map= (Map<?,?>)value;
+ if( ! map.isEmpty()){
+ JSONObject json = new JSONObject();
+ if(map.keySet().iterator().next() instanceof TypedEntityReference){
+ for(Object key : map.keySet()){
+ json.element(key.toString(), map.get(key), jsonConfig);
+ }
+ } else {
+ for (Object val : map.values()){
+ if(val instanceof LanguageString){
+ json.element(((LanguageString)val).getLanguageLabel(), val, jsonConfig);
+ } else {
+ return JSONObject.fromObject(value, jsonConfig);
+ }
+ }
+ }
+ return json;
+ }
+ }
+ return JSONObject.fromObject(value, jsonConfig);
+ }
+
+ /* (non-Javadoc)
+ * @see net.sf.json.processors.JsonValueProcessor#processObjectValue(java.lang.String, java.lang.Object, net.sf.json.JsonConfig)
+ */
+ @Override
+ public Object processObjectValue(String key, Object value,
+ JsonConfig jsonConfig) {
+ return processArrayValue(value, jsonConfig);
+ }
+
+}
<entry key="java.util.LinkedHashMap">
<bean class="eu.etaxonomy.cdm.remote.json.processor.value.MapJSONValueProcessor" />
</entry>
- <entry key="eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet">
+ <entry key="eu.etaxonomy.cdm.api.service.name.TypeDesignationSet">
<bean class="eu.etaxonomy.cdm.remote.json.processor.value.MapJSONValueProcessor" />
</entry>
<entry key="eu.etaxonomy.cdm.common.URI">
<entry key="java.util.LinkedHashMap">
<bean class="eu.etaxonomy.cdm.remote.json.processor.value.MapJSONValueProcessor" />
</entry>
- <entry key="eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet">
+ <entry key="eu.etaxonomy.cdm.api.service.name.TypeDesignationSet">
<bean class="eu.etaxonomy.cdm.remote.json.processor.value.MapJSONValueProcessor" />
</entry>
<entry key="eu.etaxonomy.cdm.common.URI">
import eu.etaxonomy.cdm.api.service.name.TypeDesignationDTO;
import eu.etaxonomy.cdm.api.service.name.TypeDesignationSetFormatter;
import eu.etaxonomy.cdm.api.service.name.TypeDesignationSetManager;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet;
import eu.etaxonomy.cdm.format.reference.NomenclaturalSourceFormatter;
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
return name;
}
- public Map<VersionableEntity,TypeDesignationWorkingSet> getOrderedTypeDesignationWorkingSets() {
- return typeDesignationManager != null ? typeDesignationManager.getOrderedTypeDesignationWorkingSets() : null;
+ public Map<VersionableEntity,TypeDesignationSet> getOrderedTypeDesignationSets() {
+ return typeDesignationManager != null ? typeDesignationManager.getOrderedTypeDesignationSets() : null;
}
- public TypeDesignationWorkingSet getTypeDesignationWorkingSet(VersionableEntity baseEntity) {
- return typeDesignationManager != null ? typeDesignationManager.getOrderedTypeDesignationWorkingSets().get(baseEntity) : null;
+ public TypeDesignationSet getTypeDesignationSet(VersionableEntity baseEntity) {
+ return typeDesignationManager != null ? typeDesignationManager.getOrderedTypeDesignationSets().get(baseEntity) : null;
}
public Set<TypeDesignationBase> getTypeDesignationsInWorkingSet(VersionableEntity baseEntity) {
Set<TypeDesignationBase> typeDesignations = new HashSet<>();
- TypeDesignationWorkingSet workingSet = getTypeDesignationWorkingSet(baseEntity);
+ TypeDesignationSet workingSet = getTypeDesignationSet(baseEntity);
for(TypeDesignationDTO<?> ref : workingSet.getTypeDesignations()){
typeDesignations.add(findTypeDesignation(ref));
}
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
/**
- * TypeDesignations which refer to the same FieldUnit (SpecimenTypeDesignation) or TaxonName
- * (NameTypeDesignation) form a working set. The <code>TypeDesignationWorkingSet</code> internally
- * works with EnityReferences to the actual TypeDesignations.
+ * TypeDesignations which refer to the same base entity (e.g. FieldUnit for SpecimenTypeDesignations
+ * or TaxonName/NameTypeDesignation for NameTypeDesignation form a type designation set.
+ * The <code>TypeDesignationSet</code> internally stores the entity base
+ * and an ordered map that maps type status (TypeDesignationStatusBase) to the type designations
+ * in the <code>TypeDesignationSet</code>.
*
- * The EntityReferences for TypeDesignations are grouped by the according TypeDesignationStatus.
* The TypeDesignationStatusBase keys can be ordered by the term order defined in the vocabulary.
*
- * A workingset can be referenced by the <code>baseEntityReference</code>.
+ * A typeDesignationSet can be referenced by the <code>baseEntity</code>.
*
* @author a.kohlbecker
+ * @author a.mueller
* @since Mar 10, 2017
*/
-public class TypeDesignationWorkingSet {
+public class TypeDesignationSet {
public static final NullTypeDesignationStatus NULL_STATUS = NullTypeDesignationStatus.SINGLETON();
private LinkedHashMap<TypeDesignationStatusBase<?>,Collection<TypeDesignationDTO>> designationByStatusMap = new LinkedHashMap<>();
-
- public enum TypeDesignationWorkingSetType {
- SPECIMEN_TYPE_DESIGNATION_WORKINGSET,
- NAME_TYPE_DESIGNATION_WORKINGSET;
- boolean isSpecimenType(){return this == SPECIMEN_TYPE_DESIGNATION_WORKINGSET;}
- boolean isNameType(){return this == NAME_TYPE_DESIGNATION_WORKINGSET;}
+ public enum TypeDesignationSetType {
+ SPECIMEN_TYPE_DESIGNATION_SET,
+ NAME_TYPE_DESIGNATION_SET;
+ boolean isSpecimenType(){return this == SPECIMEN_TYPE_DESIGNATION_SET;}
+ boolean isNameType(){return this == NAME_TYPE_DESIGNATION_SET;}
}
// ********************************* CONSTRUCTOR **************************/
- public TypeDesignationWorkingSet(VersionableEntity baseEntity) {
+ public TypeDesignationSet(VersionableEntity baseEntity) {
this.baseEntity = baseEntity;
}
return SpecimenOrObservationBase.class.isAssignableFrom(baseEntity.getClass());
}
- public TypeDesignationWorkingSetType getWorkingsetType() {
- return isSpecimenTypeDesigationWorkingSet() ? TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET : TypeDesignationWorkingSetType.NAME_TYPE_DESIGNATION_WORKINGSET;
+ public TypeDesignationSetType getWorkingsetType() {
+ return isSpecimenTypeDesigationWorkingSet() ? TypeDesignationSetType.SPECIMEN_TYPE_DESIGNATION_SET : TypeDesignationSetType.NAME_TYPE_DESIGNATION_SET;
}
/**
import org.apache.commons.lang3.StringUtils;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet.TypeDesignationWorkingSetType;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet.TypeDesignationSetType;
import eu.etaxonomy.cdm.common.CdmUtils;
import eu.etaxonomy.cdm.common.UTF8;
import eu.etaxonomy.cdm.format.reference.OriginalSourceFormatter;
}
int typeSetCount = 0;
- Map<VersionableEntity,TypeDesignationWorkingSet> orderedByTypesByBaseEntity
- = manager.getOrderedTypeDesignationWorkingSets();
- TypeDesignationWorkingSetType lastWsType = null;
+ Map<VersionableEntity,TypeDesignationSet> orderedByTypesByBaseEntity
+ = manager.getOrderedTypeDesignationSets();
+ TypeDesignationSetType lastWsType = null;
if (orderedByTypesByBaseEntity != null){
for(VersionableEntity baseEntity : orderedByTypesByBaseEntity.keySet()) {
buildTaggedTextForSingleTypeSet(manager, withBrackets, finalBuilder,
}
private void buildTaggedTextForSingleTypeSet(TypeDesignationSetManager manager, boolean withBrackets,
- TaggedTextBuilder finalBuilder, int typeSetCount, VersionableEntity baseEntity, TypeDesignationWorkingSetType lastWsType) {
+ TaggedTextBuilder finalBuilder, int typeSetCount, VersionableEntity baseEntity, TypeDesignationSetType lastWsType) {
- Map<VersionableEntity,TypeDesignationWorkingSet>
- orderedByTypesByBaseEntity = manager.getOrderedTypeDesignationWorkingSets();
- TypeDesignationWorkingSet typeDesignationWorkingSet = orderedByTypesByBaseEntity.get(baseEntity);
+ Map<VersionableEntity,TypeDesignationSet>
+ orderedByTypesByBaseEntity = manager.getOrderedTypeDesignationSets();
+ TypeDesignationSet typeDesignationSet = orderedByTypesByBaseEntity.get(baseEntity);
TaggedTextBuilder workingsetBuilder = new TaggedTextBuilder();
if(typeSetCount > 0){
//name types separately, but this is such a rare case (if at all) and
//increases complexity so it is not yet implemented
boolean isPlural = hasMultipleTypes(orderedByTypesByBaseEntity);
- if(typeDesignationWorkingSet.getWorkingsetType().isSpecimenType()){
+ if(typeDesignationSet.getWorkingsetType().isSpecimenType()){
workingsetBuilder.add(TagEnum.label, (isPlural? "Types:": "Type:"));
- } else if (typeDesignationWorkingSet.getWorkingsetType().isNameType()){
+ } else if (typeDesignationSet.getWorkingsetType().isNameType()){
workingsetBuilder.add(TagEnum.label, (isPlural? "Nametypes:": "Nametype:"));
} else {
//do nothing for now
}
}
- boolean hasExplicitBaseEntity = hasExplicitBaseEntity(baseEntity, typeDesignationWorkingSet);
+ boolean hasExplicitBaseEntity = hasExplicitBaseEntity(baseEntity, typeDesignationSet);
if(hasExplicitBaseEntity && !entityLabel(baseEntity).isEmpty()){
workingsetBuilder.add(TagEnum.specimenOrObservation, entityLabel(baseEntity), baseEntity);
}
if (withBrackets && hasExplicitBaseEntity){
workingsetBuilder.add(TagEnum.separator, TYPE_STATUS_PARENTHESIS_LEFT);
}
- for(TypeDesignationStatusBase<?> typeStatus : typeDesignationWorkingSet.keySet()) {
+ for(TypeDesignationStatusBase<?> typeStatus : typeDesignationSet.keySet()) {
typeStatusCount = buildTaggedTextForSingleTypeStatus(manager, workingsetBuilder,
- typeDesignationWorkingSet, typeStatusCount, typeStatus,
+ typeDesignationSet, typeStatusCount, typeStatus,
lastWsType, typeSetCount);
}
if (withBrackets && hasExplicitBaseEntity){
workingsetBuilder.add(TagEnum.separator, TYPE_STATUS_PARENTHESIS_RIGHT);
}
- typeDesignationWorkingSet.setRepresentation(workingsetBuilder.toString());
+ typeDesignationSet.setRepresentation(workingsetBuilder.toString());
finalBuilder.addAll(workingsetBuilder);
return;
}
* Checks if the baseType is the same as the (only?) type in the type designation workingset.
*/
private boolean hasExplicitBaseEntity(VersionableEntity baseEntity,
- TypeDesignationWorkingSet typeDesignationWorkingSet) {
- if (!typeDesignationWorkingSet.isSpecimenWorkingSet()){
+ TypeDesignationSet typeDesignationSet) {
+ if (!typeDesignationSet.isSpecimenWorkingSet()){
return false; //name type designations are not handled here
}else{
UUID baseUuid = baseEntity.getUuid();
- for (TypeDesignationDTO<?> dto: typeDesignationWorkingSet.getTypeDesignations()){
+ for (TypeDesignationDTO<?> dto: typeDesignationSet.getTypeDesignations()){
if (!baseUuid.equals(dto.getTypeUuid())){
return true;
}
}
private int buildTaggedTextForSingleTypeStatus(TypeDesignationSetManager manager,
- TaggedTextBuilder workingsetBuilder, TypeDesignationWorkingSet typeDesignationWorkingSet,
+ TaggedTextBuilder workingsetBuilder, TypeDesignationSet typeDesignationSet,
int typeStatusCount, TypeDesignationStatusBase<?> typeStatus,
- TypeDesignationWorkingSetType lastWsType, int typeSetCount) {
+ TypeDesignationSetType lastWsType, int typeSetCount) {
//starting separator
if(typeStatusCount++ > 0){
workingsetBuilder.add(TagEnum.separator, TYPE_STATUS_SEPARATOR);
}
- boolean isPlural = typeDesignationWorkingSet.get(typeStatus).size() > 1;
+ boolean isPlural = typeDesignationSet.get(typeStatus).size() > 1;
String label = null;
- if(typeStatus != TypeDesignationWorkingSet.NULL_STATUS){
+ if(typeStatus != TypeDesignationSet.NULL_STATUS){
label = typeStatus.getLabel();
- }else if (typeDesignationWorkingSet.getWorkingsetType() != lastWsType
+ }else if (typeDesignationSet.getWorkingsetType() != lastWsType
&& (workingsetBuilder.size() > 0 && typeSetCount > 0)){
//only for the first name type (coming after a specimen type add the label (extremely rare case, if at all existing)
- if (typeDesignationWorkingSet.getWorkingsetType().isNameType()) {
+ if (typeDesignationSet.getWorkingsetType().isNameType()) {
label = "nametype";
- }else if (typeDesignationWorkingSet.getWorkingsetType().isSpecimenType()) {
+ }else if (typeDesignationSet.getWorkingsetType().isSpecimenType()) {
label = "type";
}
}
//designation + sources
int typeDesignationCount = 0;
- for(TypeDesignationDTO<?> typeDesignationDTO : createSortedList(typeDesignationWorkingSet, typeStatus)) {
+ for(TypeDesignationDTO<?> typeDesignationDTO : createSortedList(typeDesignationSet, typeStatus)) {
TypeDesignationBase<?> typeDes = manager.findTypeDesignation(typeDesignationDTO.getUuid());
typeDesignationCount = buildTaggedTextForSingleType(typeDes, withCitation,
}
private List<TypeDesignationDTO> createSortedList(
- TypeDesignationWorkingSet typeDesignationWorkingSet, TypeDesignationStatusBase<?> typeStatus) {
+ TypeDesignationSet typeDesignationSet, TypeDesignationStatusBase<?> typeStatus) {
- List<TypeDesignationDTO> typeDesignationDTOs = new ArrayList<>(typeDesignationWorkingSet.get(typeStatus));
+ List<TypeDesignationDTO> typeDesignationDTOs = new ArrayList<>(typeDesignationSet.get(typeStatus));
Collections.sort(typeDesignationDTOs);
return typeDesignationDTOs;
}
* or if it has a single working set but this workingset has multiple type designations.
*/
private boolean hasMultipleTypes(
- Map<VersionableEntity,TypeDesignationWorkingSet> typeWorkingSets) {
+ Map<VersionableEntity,TypeDesignationSet> typeWorkingSets) {
if (typeWorkingSets == null || typeWorkingSets.isEmpty()){
return false;
}else if (typeWorkingSets.keySet().size() > 1) {
return true;
}
- TypeDesignationWorkingSet singleSet = typeWorkingSets.values().iterator().next();
+ TypeDesignationSet singleSet = typeWorkingSets.values().iterator().next();
return singleSet.getTypeDesignations().size() > 1;
}
import java.util.UUID;
import eu.etaxonomy.cdm.api.service.exception.RegistrationValidationException;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet.TypeDesignationWorkingSetType;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet.TypeDesignationSetType;
import eu.etaxonomy.cdm.compare.name.NullTypeDesignationStatus;
import eu.etaxonomy.cdm.compare.name.TypeDesignationStatusComparator;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
* if the former is missing. The type designations per base type are furthermore ordered by the {@link TypeDesignationStatusBase}.
*
* The TypeDesignationSetManager also provides string representations of the whole ordered set of all
- * {@link TypeDesignationBase TypeDesignations} and of the TypeDesignationWorkingSets:
+ * {@link TypeDesignationBase TypeDesignations} and of the TypeDesignationSets:
* <ul>
* <li>{@link #print()}
- * <li>{@link #getOrderedTypeDesignationWorkingSets()} ... {@link TypeDesignationWorkingSet#getLabel()}
+ * <li>{@link #getOrderedTypeDesignationSets()} ... {@link TypeDesignationSet#getLabel()}
* </ul>
* Prior using the representations you need to trigger their generation by calling {@link #buildString()}
*
*
* {@inheritDoc}
*/
- private Comparator<Entry<VersionableEntity,TypeDesignationWorkingSet>> entryComparator = (o1,o2)->{
+ private Comparator<Entry<VersionableEntity,TypeDesignationSet>> entryComparator = (o1,o2)->{
- TypeDesignationWorkingSet ws1 = o1.getValue();
- TypeDesignationWorkingSet ws2 = o2.getValue();
+ TypeDesignationSet ws1 = o1.getValue();
+ TypeDesignationSet ws2 = o2.getValue();
if (ws1.getWorkingsetType() != ws2.getWorkingsetType()){
//first specimen types, then name types (very rare case anyway)
- return ws1.getWorkingsetType() == TypeDesignationWorkingSetType.NAME_TYPE_DESIGNATION_WORKINGSET? 1:-1;
+ return ws1.getWorkingsetType() == TypeDesignationSetType.NAME_TYPE_DESIGNATION_SET? 1:-1;
}
boolean hasStatus1 = !ws1.keySet().contains(null) && !ws1.keySet().contains(NullTypeDesignationStatus.SINGLETON());
* 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<VersionableEntity,TypeDesignationWorkingSet> orderedByTypesByBaseEntity;
+ private LinkedHashMap<VersionableEntity,TypeDesignationSet> orderedByTypesByBaseEntity;
private List<String> problems = new ArrayList<>();
*/
protected void mapAndSort() {
- Map<VersionableEntity,TypeDesignationWorkingSet> byBaseEntityByTypeStatus = new HashMap<>();
+ Map<VersionableEntity,TypeDesignationSet> byBaseEntityByTypeStatus = new HashMap<>();
this.typeDesignations.values().forEach(td -> mapTypeDesignation(byBaseEntityByTypeStatus, td));
orderedByTypesByBaseEntity = orderByTypeByBaseEntity(byBaseEntityByTypeStatus);
}
- private void mapTypeDesignation(Map<VersionableEntity,TypeDesignationWorkingSet> byBaseEntityByTypeStatus,
+ private void mapTypeDesignation(Map<VersionableEntity,TypeDesignationSet> byBaseEntityByTypeStatus,
TypeDesignationBase<?> td){
td = HibernateProxyHelper.deproxy(td);
getTypeUuid(td));
if(!byBaseEntityByTypeStatus.containsKey(baseEntity)){
- byBaseEntityByTypeStatus.put(baseEntity, new TypeDesignationWorkingSet(baseEntity));
+ byBaseEntityByTypeStatus.put(baseEntity, new TypeDesignationSet(baseEntity));
}
byBaseEntityByTypeStatus.get(baseEntity).insert(status, typeDesignationDTO);
return baseEntityReference;
}
- private LinkedHashMap<VersionableEntity,TypeDesignationWorkingSet> orderByTypeByBaseEntity(
- Map<VersionableEntity,TypeDesignationWorkingSet> stringsByTypeByBaseEntity){
+ private LinkedHashMap<VersionableEntity,TypeDesignationSet> orderByTypeByBaseEntity(
+ Map<VersionableEntity,TypeDesignationSet> stringsByTypeByBaseEntity){
// order the FieldUnit TypeName keys
- Set<Entry<VersionableEntity,TypeDesignationWorkingSet>> entrySet
+ Set<Entry<VersionableEntity,TypeDesignationSet>> entrySet
= stringsByTypeByBaseEntity.entrySet();
- LinkedList<Entry<VersionableEntity,TypeDesignationWorkingSet>> baseEntityKeyList
+ LinkedList<Entry<VersionableEntity,TypeDesignationSet>> baseEntityKeyList
= new LinkedList<>(entrySet);
Collections.sort(baseEntityKeyList, entryComparator);
// new LinkedHashMap for the ordered FieldUnitOrTypeName keys
- LinkedHashMap<VersionableEntity,TypeDesignationWorkingSet> stringsOrderedbyBaseEntityOrderdByType
+ LinkedHashMap<VersionableEntity,TypeDesignationSet> stringsOrderedbyBaseEntityOrderdByType
= new LinkedHashMap<>(stringsByTypeByBaseEntity.size());
- for(Entry<VersionableEntity,TypeDesignationWorkingSet> entry : baseEntityKeyList){
+ for(Entry<VersionableEntity,TypeDesignationSet> entry : baseEntityKeyList){
VersionableEntity baseEntity = entry.getKey();
- TypeDesignationWorkingSet typeDesignationWorkingSet = stringsByTypeByBaseEntity.get(baseEntity);
+ TypeDesignationSet typeDesignationSet = stringsByTypeByBaseEntity.get(baseEntity);
// order the TypeDesignationStatusBase keys
- List<TypeDesignationStatusBase<?>> keyList = new LinkedList<>(typeDesignationWorkingSet.keySet());
+ List<TypeDesignationStatusBase<?>> keyList = new LinkedList<>(typeDesignationSet.keySet());
Collections.sort(keyList, new TypeDesignationStatusComparator());
// new LinkedHashMap for the ordered TypeDesignationStatusBase keys
- TypeDesignationWorkingSet orderedStringsByOrderedTypes = new TypeDesignationWorkingSet(
- typeDesignationWorkingSet.getBaseEntity());
- keyList.forEach(key -> orderedStringsByOrderedTypes.put(key, typeDesignationWorkingSet.get(key)));
+ TypeDesignationSet orderedStringsByOrderedTypes = new TypeDesignationSet(
+ typeDesignationSet.getBaseEntity());
+ keyList.forEach(key -> orderedStringsByOrderedTypes.put(key, typeDesignationSet.get(key)));
stringsOrderedbyBaseEntityOrderdByType.put(baseEntity, orderedStringsByOrderedTypes);
}
return this.typeDesignations.get(uuid);
}
- public Map<VersionableEntity,TypeDesignationWorkingSet> getOrderedTypeDesignationWorkingSets() {
+ public Map<VersionableEntity,TypeDesignationSet> getOrderedTypeDesignationSets() {
return orderedByTypesByBaseEntity;
}
, result
);
- Map<VersionableEntity,TypeDesignationWorkingSet> orderedTypeDesignations =
- typeDesignationManager.getOrderedTypeDesignationWorkingSets();
- Iterator<TypeDesignationWorkingSet> byStatusMapIterator = orderedTypeDesignations.values().iterator();
+ Map<VersionableEntity,TypeDesignationSet> orderedTypeDesignations =
+ typeDesignationManager.getOrderedTypeDesignationSets();
+ Iterator<TypeDesignationSet> byStatusMapIterator = orderedTypeDesignations.values().iterator();
Iterator<TypeDesignationStatusBase<?>> keyIt_1 = byStatusMapIterator.next().keySet().iterator();
Iterator<TypeDesignationStatusBase<?>> keyIt_2 = byStatusMapIterator.next().keySet().iterator();
assertEquals("isotype", keyIt_1.next().getLabel());
BGBM BDI Projects / cdmlib.git / commitdiff