/ - Diff - EDIT - EDIT Project Management

« Previous | Next »

Revision 6e8ebcb6

ref #5952, ref #5951 add identityCache formatting to SpecimenOrObservationBase cache strategies

             this.identityCache = identityCache;
+        }
         /**
          * Sets the identity (short) cache. For how to use see {@link #setTitleCache(String, boolean)}
          */
         public void setIdentityCache(String identityCache, boolean isProtected) {
             this.protectedIdentityCache = isProtected;
             setIdentityCache(identityCache);
             this.protectedIdentityCache = isProtected;
+        }
         /**

             };
+        }
         //NOTE still need to discuss, if the identity cache for derived units
         //should also include the identity cache for field units (see also #5951).
         //This may make sense for searching, but is less comfortable in
         //tree representations.
         //For search it might be not so urgent if showing both the identity cache
         //followed by the titleCache whcih includes field unit information.
         @Override
         protected String doGetIdentityCache(DerivedUnit derivedUnit) {
             String specimenLabel = getSpecimenLabel(derivedUnit);
             if (isBlank(specimenLabel)){
                 return getTitleCache(derivedUnit);
             }else{
                 //NOTE: in future we may add further information if not both data are given
                 //      collection code/label AND unit number
                 return specimenLabel;
+            }
+        }
         /**
          * Produces the collection code and number which is the combination of the collection code and
          * accession number or barcode.

     		return result;
+    	}
     	//NOTE: this is a first implementation, it may be adapted in future
         @Override
         protected String doGetIdentityCache(DnaSample dnaSample) {
             String result = getCollectionAndAccession(dnaSample);
             //sample designation
             if (isBlank(result)){
                 result = dnaSample.getIdentifierString(DefinedTerm.uuidSampleDesignation);
+            }
             //any other identifier
             if (isBlank(result)){
                 if (!dnaSample.getIdentifiers().isEmpty()){
                     result = dnaSample.getIdentifiers().get(0).getIdentifier();
+                }
+            }
             if (isBlank(result)){
                 return doGetTitleCache(dnaSample);
             }else{
                 return result;
+            }
+        }
+    }

             return result;
+        }
         @Override
         protected String doGetIdentityCache(FieldUnit fieldUnit) {
             if (fieldUnit == null){
                 return null;
+            }
             String collectorAndFieldNumber = getCollectorAndFieldNumber(fieldUnit);
             if (isBlank(collectorAndFieldNumber)){
                 return this.doGetTitleCache(fieldUnit);
             }else{
                 //NOTE: in future we may decide to return further information if
                 //not both information is available collector AND fieldNumber.
                 return collectorAndFieldNumber;
+            }
+        }
         private String getFieldData(FieldUnit fieldUnit) {
             if (fieldUnit.isProtectedTitleCache()){

     		return result;
+    	}
     	//NOTE: this is a first implementation, it may be adapted in future
         @Override
         protected String doGetIdentityCache(MediaSpecimen mediaSpecimen) {
             String collectionAndAccession = getCollectionAndAccession(mediaSpecimen);
             if (isBlank(collectionAndAccession)){
                 return getTitleCache(mediaSpecimen);
             }else{
                 return collectionAndAccession;
+            }
+        }
+    }

             return getTitleCache(specimen, false);
+        }
         /**
          * Returns the title cache for the given specimen.
+         *
          * @param emptyIfBlank if <code>true</code> a blank result will be returned as empty string. Otherwise
          * the toString() result is returned.
          * @return the title cache
          */
         public String getTitleCache(T specimen, boolean emptyIfBlank) {
             if (specimen == null){
                 return null;
-...
             return result;
+        }
         public String getIdentityCache(T specimen){
             boolean emptyIfBlank = true;  //for future
             if (specimen == null){
                 return null;
+            }
             String result = doGetIdentityCache(specimen);
             if (isBlank(result)){
                 return getTitleCache(specimen, emptyIfBlank);
+            }
             return result;
+        }
         protected abstract String doGetTitleCache(T occurrence);
         protected abstract String doGetIdentityCache(T occurrence);
         protected String getCollectionAndAccession(T occurrence){
             if (occurrence.isInstanceOf(FieldUnit.class)){
                 return null;   //does not exist for field units

Also available in: Unified diff