Merge pull request biojava#623 from andreasprlic/fix622

andreasprlic · web-flow · commit 16945e7bf725 · 2017-02-06T12:07:34.000-08:00
biojava#622 removal of a few loops.
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/io/mmcif/ChemicalComponentDictionary.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/io/mmcif/ChemicalComponentDictionary.java
@@ -127,6 +127,16 @@ public void addChemComp(ChemComp comp){
 		}
 	}
 
+	/** Returns the number of ChemComps in this dictionary
+	 *
+	 * @return nr. of ChemComps
+	 */
+	public int size(){
+
+		return dictionary.size();
+
+	}
+
 	public ChemComp getChemComp(String id){
 		return dictionary.get(id);
 	}
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/io/mmcif/chem/PolymerType.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/io/mmcif/chem/PolymerType.java
@@ -22,10 +22,7 @@
 package org.biojava.nbio.structure.io.mmcif.chem;
 
 import java.io.Serializable;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 
 /**
  * Enumerates the classification of polymers.
@@ -38,7 +35,6 @@
 public enum PolymerType implements Serializable
 {
 
-
 	/**
 	 * polypeptide(L)
 	 */
@@ -94,6 +90,19 @@ public enum PolymerType implements Serializable
 	 */
 	unknown(null);
 
+	static Map<String,PolymerType> lookupTable = new HashMap<>();
+
+	static {
+
+		for (PolymerType rt : PolymerType.values() ) {
+				if ( rt == unknown)
+					continue;
+				lookupTable.put(rt.entity_poly_type,rt);
+				lookupTable.put(rt.entity_poly_type.toLowerCase(),rt);
+		}
+	}
+
+
 	PolymerType(String entity_poly_type)
 	{
 		this.entity_poly_type = entity_poly_type;
@@ -102,6 +111,19 @@ public enum PolymerType implements Serializable
 
 	public static PolymerType polymerTypeFromString(String polymerType)
 	{
+
+		if ( polymerType.equalsIgnoreCase(peptide.entity_poly_type))
+			return peptide;
+
+		PolymerType ptype = lookupTable.get(polymerType);
+		if ( ptype != null)
+			return ptype;
+
+		ptype = lookupTable.get(polymerType.toLowerCase());
+		if ( ptype != null)
+			return ptype;
+
+
 		for(PolymerType pt : PolymerType.values())
 		{
 			if(polymerType.equals(pt.entity_poly_type))
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/io/mmcif/chem/ResidueType.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/io/mmcif/chem/ResidueType.java
@@ -22,6 +22,8 @@
 package org.biojava.nbio.structure.io.mmcif.chem;
 
 import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
 
 
 /**
@@ -72,10 +74,21 @@ public enum ResidueType implements Serializable {
 	nonPolymer(null, "non-polymer"),
 	otherChemComp(null, "other");
 
+
+	static Map<String,ResidueType> lookupTable = new HashMap<>();
+
+	static {
+
+		for (ResidueType rt : ResidueType.values() ) {
+				lookupTable.put(rt.chem_comp_type,rt);
+				lookupTable.put(rt.chem_comp_type.toLowerCase(),rt);
+		}
+	}
 	ResidueType(PolymerType pt, String chem_comp_type)
 	{
 		this.polymerType = pt;
 		this.chem_comp_type = chem_comp_type;
+
 	}
 
 	/**
@@ -94,12 +107,33 @@ public enum ResidueType implements Serializable {
 	 */
 	public final String chem_comp_type;
 
+	/** Get ResidueType by chem_comp_type
+	 *
+	 * @param chem_comp_type e.g. L-peptide linking
+	 * @return
+	 */
 	public static ResidueType getResidueTypeFromString(String chem_comp_type)
 	{
 
-		chem_comp_type = chem_comp_type.replaceAll("'", "");
-		chem_comp_type = chem_comp_type.replaceAll("\"", "");
+		// Almost all calls to this method are for L-peptide linking. Use this knowledge for a shortcut.
+
+		if ( chem_comp_type.equalsIgnoreCase(lPeptideLinking.chem_comp_type) )
+			return lPeptideLinking;
+
+		ResidueType rtype = lookupTable.get(chem_comp_type);
+		if ( rtype != null)
+			return rtype;
+
+		/** Unfortunately it can be guaranteed that chem_comp_type case sensitivity is preserved.
+		 * E.g. mmtf has it all upper-case. As such we need to do a second check
+		 */
+		rtype = lookupTable.get(chem_comp_type.toLowerCase());
+		if ( rtype != null)
+			return rtype;
+
+
 
+		// preserving previous behaviour. Not sure if this is really necessary?
 		for(ResidueType rt : ResidueType.values())
 		{
 			if(rt.chem_comp_type.equalsIgnoreCase(chem_comp_type))

Original file line number	Diff line number	Diff line change
`@@ -127,6 +127,16 @@ public void addChemComp(ChemComp comp){`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`
	`130`	`+ /** Returns the number of ChemComps in this dictionary`
	`131`	`+ *`
	`132`	`+ * @return nr. of ChemComps`
	`133`	`+ */`
	`134`	`+ public int size(){`
	`135`	`+`
	`136`	`+ return dictionary.size();`
	`137`	`+`
	`138`	`+ }`
	`139`	`+`
`130`	`140`	`public ChemComp getChemComp(String id){`
`131`	`141`	`return dictionary.get(id);`
`132`	`142`	`}`