Merge "Optimize the areas where its creating extra memory"

6 files changed, 224 insertions, 112 deletions

diff --git a/aai-core/src/main/java/org/onap/aai/introspection/Introspector.java b/aai-core/src/main/java/org/onap/aai/introspection/Introspector.java
index 269d6330..21299f79 100644
--- a/aai-core/src/main/java/org/onap/aai/introspection/Introspector.java
+++ b/aai-core/src/main/java/org/onap/aai/introspection/Introspector.java
@@ -24,9 +24,12 @@ import com.att.eelf.configuration.EELFManager;
 import com.google.common.base.CaseFormat;
 import org.apache.commons.lang.ClassUtils;
 import org.eclipse.persistence.exceptions.DynamicException;
+import org.onap.aai.config.SpringContextAware;
 import org.onap.aai.introspection.exceptions.AAIUnknownObjectException;
 import org.onap.aai.logging.ErrorLogHelper;
 import org.onap.aai.logging.LogFormatTools;
+import org.onap.aai.nodes.CaseFormatStore;
+import org.onap.aai.nodes.NodeIngestor;
 import org.onap.aai.restcore.MediaType;
 import org.onap.aai.schema.enums.ObjectMetadata;
 import org.onap.aai.schema.enums.PropertyMetadata;
@@ -50,13 +53,26 @@ public abstract class Introspector implements Cloneable {
 	private Set<String> uniqueProperties = null;
 	private Set<String> indexedProperties = null;
 	private Set<String> allKeys = null;
+
+    protected CaseFormatStore caseFormatStore = null;
+    protected NodeIngestor nodeIngestor;
+
 	protected Introspector(Object obj) {
+        this.nodeIngestor    = SpringContextAware.getBean(NodeIngestor.class);
+        this.caseFormatStore = nodeIngestor.getCaseFormatStore();
 	}
 
 	public abstract boolean hasProperty(String name);
 
 	protected String convertPropertyName (String name) {
-		return CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, name);
+	    return caseFormatStore
+            .fromLowerHyphenToLowerCamel(name)
+            .orElseGet(
+                () -> {
+                    LOGGER.debug("Unable to find {} in the store from lower hyphen to lower camel", name);
+                    return CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, name);
+                }
+            );
 	}
 
 	protected abstract Object get(String name);
@@ -198,7 +214,7 @@ public abstract class Introspector implements Cloneable {
 	 * @param obj the value to be set
 	 * @return
 	 */
-	public void setValue(String name, Object obj) throws IllegalArgumentException {
+	public void setValue(String name, Object obj) {
 		Object box = this.castValueAccordingToSchema(name, obj);
 
 		name = convertPropertyName(name);
@@ -558,8 +574,6 @@ public abstract class Introspector implements Cloneable {
 
 	public abstract String marshal(MarshallerProperties properties);
 
-	public abstract Object clone();
-
 	public abstract Object getUnderlyingObject();
 
 	public String marshal(boolean formatted) {
diff --git a/aai-core/src/main/java/org/onap/aai/introspection/MoxyLoader.java b/aai-core/src/main/java/org/onap/aai/introspection/MoxyLoader.java
index fa52d62f..35583d7c 100644
--- a/aai-core/src/main/java/org/onap/aai/introspection/MoxyLoader.java
+++ b/aai-core/src/main/java/org/onap/aai/introspection/MoxyLoader.java
@@ -32,12 +32,12 @@ import org.onap.aai.introspection.exceptions.AAIUnknownObjectException;
 import org.onap.aai.introspection.exceptions.AAIUnmarshallingException;
 import org.onap.aai.logging.ErrorLogHelper;
 import org.onap.aai.logging.LogFormatTools;
+import org.onap.aai.nodes.CaseFormatStore;
 import org.onap.aai.nodes.NodeIngestor;
 import org.onap.aai.restcore.MediaType;
 import org.onap.aai.schema.enums.ObjectMetadata;
 import org.onap.aai.setup.SchemaVersion;
 import org.onap.aai.workarounds.NamingExceptions;
-import org.springframework.stereotype.Component;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
 import javax.xml.transform.stream.StreamSource;
@@ -49,19 +49,22 @@ import java.util.stream.Collectors;
 
 public class MoxyLoader extends Loader {
 
+    private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(MoxyLoader.class);
+
 	private DynamicJAXBContext jaxbContext = null;
-	private EELFLogger LOGGER = EELFManager.getInstance().getLogger(MoxyLoader.class);
 	private Map<String, Introspector> allObjs = null;
 
 	private Map<SchemaVersion, MoxyLoader> moxyLoaderFactory;
 
 	private NodeIngestor nodeIngestor;
+	private CaseFormatStore caseFormatStore;
 
 	private Set<String> namedProps;
 
 	public MoxyLoader(SchemaVersion version, NodeIngestor nodeIngestor) {
 		super(version, ModelType.MOXY);
 		this.nodeIngestor = nodeIngestor;
+		this.caseFormatStore = nodeIngestor.getCaseFormatStore();
 		process(version);
 	}
 
@@ -79,6 +82,16 @@ public class MoxyLoader extends Loader {
 		return IntrospectorFactory.newInstance(ModelType.MOXY, objectFromName(name));
 	}
 
+	private boolean containsUpperCase(String str){
+
+	    for(int i = 0; i < str.length(); i++){
+	        if(Character.isUpperCase(str.charAt(i))){
+	            return true;
+            }
+        }
+
+        return false;
+    }
 	/**
 	 * {@inheritDoc}
 	 */
@@ -92,10 +105,17 @@ public class MoxyLoader extends Loader {
 		final String upperCamel;
 
 		//Contains any uppercase, then assume it's upper camel
-		if (name.matches(".*[A-Z].*")) {
+		if (containsUpperCase(name)) {
 			upperCamel = sanitizedName;
 		} else {
-			upperCamel = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, sanitizedName);
+			upperCamel = caseFormatStore
+                .fromLowerHyphenToUpperCamel(sanitizedName)
+                .orElseGet(
+                    () -> {
+                        LOGGER.debug("Unable to find {} in the store for lower hyphen to upper camel", sanitizedName);
+                        return CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, sanitizedName);
+                    }
+                );
 		}
 
 		try {
@@ -153,7 +173,7 @@ public class MoxyLoader extends Loader {
 		if (this.allObjs != null) {
 			return allObjs;
 		} else {
-			ImmutableMap.Builder<String, Introspector> map = new ImmutableMap.Builder<String, Introspector>();
+			ImmutableMap.Builder<String, Introspector> map = new ImmutableMap.Builder<>();
 			Set<String> objs = objectsInVersion();
 			for (String objName : objs) {
 				try {
@@ -178,7 +198,6 @@ public class MoxyLoader extends Loader {
 			LOGGER.warn("Exception while enumerating objects for API version " + getVersion() + " (returning partial results) " + LogFormatTools.getStackTop(e));
 		}
 
-		//result.remove("EdgePropNames");
 		return result;
 	}
 
@@ -199,20 +218,4 @@ public class MoxyLoader extends Loader {
 	public DynamicJAXBContext getJAXBContext() {
 		return this.jaxbContext;
 	}
-
-	/*
-	 * Im keeping this for now - Just in case
-	 */
-	/*private static class Helper {
-		private static final Map<SchemaVersion, MoxyLoader> INSTANCEMAP = new ConcurrentHashMap<>();
-
-		private Helper() {}
-
-		private static MoxyLoader getLoaderBySchemaVersion(SchemaVersion v) {
-			if (!INSTANCEMAP.containsKey(v)) {
-				INSTANCEMAP.put(v, new MoxyLoader(v, nodeIngestor));
-			}
-			return INSTANCEMAP.get(v);
-		}
-	}*/
 }
diff --git a/aai-core/src/main/java/org/onap/aai/introspection/MoxyStrategy.java b/aai-core/src/main/java/org/onap/aai/introspection/MoxyStrategy.java
index f0d487e8..455e7846 100644
--- a/aai-core/src/main/java/org/onap/aai/introspection/MoxyStrategy.java
+++ b/aai-core/src/main/java/org/onap/aai/introspection/MoxyStrategy.java
@@ -23,35 +23,31 @@ import com.att.eelf.configuration.EELFLogger;
 import com.att.eelf.configuration.EELFManager;
 import com.google.common.base.CaseFormat;
 import com.google.common.base.Joiner;
-
-
 import org.eclipse.persistence.descriptors.ClassDescriptor;
 import org.eclipse.persistence.dynamic.DynamicEntity;
 import org.eclipse.persistence.dynamic.DynamicType;
 import org.eclipse.persistence.exceptions.DynamicException;
-import org.eclipse.persistence.jaxb.UnmarshallerProperties;
 import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext;
 import org.eclipse.persistence.mappings.DatabaseMapping;
 import org.eclipse.persistence.oxm.XMLField;
 import org.eclipse.persistence.oxm.mappings.XMLCompositeCollectionMapping;
 import org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping;
 import org.onap.aai.config.SpringContextAware;
+import org.onap.aai.logging.LogFormatTools;
+import org.onap.aai.nodes.CaseFormatStore;
 import org.onap.aai.nodes.NodeIngestor;
 import org.onap.aai.restcore.MediaType;
 import org.onap.aai.schema.enums.ObjectMetadata;
 import org.onap.aai.schema.enums.PropertyMetadata;
 import org.onap.aai.setup.SchemaVersion;
 import org.springframework.web.util.UriUtils;
+
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
-import javax.xml.bind.Unmarshaller;
-import javax.xml.transform.stream.StreamSource;
-import java.io.StringReader;
 import java.io.StringWriter;
 import java.io.UnsupportedEncodingException;
 import java.util.*;
 import java.util.Map.Entry;
-import java.util.stream.Collectors;
 
 public class MoxyStrategy extends Introspector {
 
@@ -60,8 +56,6 @@ public class MoxyStrategy extends Introspector {
 	private DynamicType internalType = null;
 	private DynamicJAXBContext jaxbContext = null;
 	private ClassDescriptor cd = null;
-	private Marshaller marshaller = null;
-	private Unmarshaller unmarshaller = null;
 	private SchemaVersion version = null;
 	private Set<String> properties = null;
 	private Set<String> keys = null;
@@ -69,14 +63,11 @@ public class MoxyStrategy extends Introspector {
 
 	private boolean isInitialized = false;
 
-	private NodeIngestor nodeIngestor;
-
 	protected MoxyStrategy(Object obj) {
 		super(obj);
 		/* must look up the correct jaxbcontext for this object */
 		className = MoxyStrategy.class.getSimpleName();
 		internalObject = (DynamicEntity)obj;
-		nodeIngestor = SpringContextAware.getBean(NodeIngestor.class);
 		version = nodeIngestor.getVersionFromClassName(internalObject.getClass().getName());
 		super.loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(getModelType(), version);
 		jaxbContext = nodeIngestor.getContextForVersion(version);
@@ -84,15 +75,6 @@ public class MoxyStrategy extends Introspector {
 		internalType = jaxbContext.getDynamicType(simpleName);
 
 		cd = internalType.getDescriptor();
-		try {
-			marshaller = jaxbContext.createMarshaller();
-
-			unmarshaller = jaxbContext.createUnmarshaller();
-
-		} catch (JAXBException e) {
-
-		}
-
 	}
 
 	private void init() {
@@ -100,21 +82,26 @@ public class MoxyStrategy extends Introspector {
 
 		Set<String> props = new LinkedHashSet<>();
 		for (String s : internalType.getPropertiesNames()) {
-			props.add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, s));
+		    String value = caseFormatStore
+                .fromLowerCamelToLowerHyphen(s)
+                .orElseGet(
+                    () -> {
+                        LOGGER.debug("Unable to find {} in the store from lower camel to lower hyphen", s);
+                        return CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, s);
+                    }
+                );
+			props.add(value);
 
 		}
 		props = Collections.unmodifiableSet(props);
 		this.properties = props;
 
 		Set<String> requiredProps = new LinkedHashSet<>();
-		requiredProps = new LinkedHashSet<>();
 		for (DatabaseMapping dm : cd.getMappings()) {
 			if (dm.getField() instanceof XMLField) {
 				XMLField x = (XMLField)dm.getField();
-				if (x != null) {
-					if (x.isRequired()) {
-						requiredProps.add(this.removeXPathDescriptor(x.getName()));
-					}
+				if (x != null && x.isRequired()) {
+					requiredProps.add(this.removeXPathDescriptor(x.getName()));
 				}
 			}
 		}
@@ -145,7 +132,7 @@ public class MoxyStrategy extends Introspector {
 	}
 
 	@Override
-	public void set(String name, Object obj) throws IllegalArgumentException {
+	public void set(String name, Object obj){
 
 		internalObject.set(name, obj);
 	}
@@ -257,10 +244,26 @@ public class MoxyStrategy extends Introspector {
 	public String getChildName() {
 
 		String className = internalObject.getClass().getSimpleName();
-		String lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
+		String lowerHyphen = caseFormatStore
+            .fromUpperCamelToLowerHyphen(className)
+            .orElseGet(
+                () -> {
+                    LOGGER.debug("Unable to find {} in the store for upper camel to lower hyphen", className);
+                    return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
+                }
+            );
 
 		if (this.isContainer()) {
-			lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN,this.getGenericTypeClass(this.getProperties().iterator().next()).getSimpleName());
+		    String upperCamel = this.getGenericTypeClass(this.getProperties().iterator().next()).getSimpleName();
+
+			lowerHyphen = caseFormatStore
+                .fromUpperCamelToLowerHyphen(upperCamel)
+                .orElseGet(
+                    () -> {
+                        LOGGER.debug("Unable to find {} in the store for upper camel to lower hyphen", upperCamel);
+                        return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, upperCamel);
+                    }
+                );
 		}
 
 		return lowerHyphen;
@@ -269,14 +272,12 @@ public class MoxyStrategy extends Introspector {
 	@Override
 	public String getName() {
 		String className = internalObject.getClass().getSimpleName();
-		String lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
-		/*
-		if (this.isContainer()) {
-			lowerHyphen = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN,this.getGenericTypeClass(this.getProperties().get(0)).getSimpleName());
-		}*/
-
-
-		return lowerHyphen;
+		return caseFormatStore
+            .fromUpperCamelToLowerHyphen(className)
+            .orElseGet(() -> {
+                LOGGER.debug("Unable to find {} in the store for upper camel to lower hyphen", className);
+                return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, className);
+            });
 	}
 
 	@Override
@@ -313,7 +314,6 @@ public class MoxyStrategy extends Introspector {
 	@Override
 	public String preProcessKey (String key) {
 		String result = "";
-		//String trimmedRestURI = restURI.replaceAll("/[\\w\\-]+?/[\\w\\-]+?$", "");
 		String[] split = key.split("/");
 		int i = 0;
 		for (i = split.length-1; i >= 0; i--) {
@@ -334,6 +334,7 @@ public class MoxyStrategy extends Introspector {
 	public String marshal(MarshallerProperties properties) {
 		StringWriter result = new StringWriter();
         try {
+            Marshaller marshaller = jaxbContext.createMarshaller();
         	if (properties.getMediaType().equals(MediaType.APPLICATION_JSON_TYPE)) {
 				marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.MEDIA_TYPE, "application/json");
 		        marshaller.setProperty(org.eclipse.persistence.jaxb.MarshallerProperties.JSON_INCLUDE_ROOT, properties.getIncludeRoot());
@@ -344,31 +345,13 @@ public class MoxyStrategy extends Introspector {
  	        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, properties.getFormatted());
 	        marshaller.marshal(this.internalObject, result);
 		} catch (JAXBException e) {
-			//e.printStackTrace();
+            LOGGER.warn("Encountered an jaxb exception during marshalling ", LogFormatTools.getStackTop(e));
 		}
 
         return result.toString();
 	}
 
 	@Override
-	public Object clone() {
-		Object result = null;
-		 try {
-				unmarshaller = jaxbContext.createUnmarshaller();
-
-		        unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, "application/json");
-		        unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, false);
-				unmarshaller.setProperty(UnmarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, true);
-
-				result = unmarshaller.unmarshal(new StreamSource(new StringReader(this.marshal(true))), this.internalObject.getClass()).getValue();
-			 } catch (JAXBException e) {
-					// TODO Auto-generated catch block
-					//e.printStackTrace();
-			}
-		 result = IntrospectorFactory.newInstance(getModelType(), result);
-		 return result;
-	}
-	@Override
 	public ModelType getModelType() {
 		return ModelType.MOXY;
 	}
diff --git a/aai-schema-ingest/src/main/java/org/onap/aai/nodes/CaseFormatStore.java b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/CaseFormatStore.java
new file mode 100644
index 00000000..69a153da
--- /dev/null
+++ b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/CaseFormatStore.java
@@ -0,0 +1,105 @@
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.aai
+ * ================================================================================
+ * Copyright © 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+package org.onap.aai.nodes;
+
+import com.google.common.base.CaseFormat;
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * CaseFormatStore stores the converted strings from
+ * lower hyphen (example-object) to lower camel case (exampleObject)
+ * so it avoids the creation of the object for every single request
+ * and cause an issue with taking too much memory just for the conversion
+ */
+public class CaseFormatStore {
+
+    private final Map<String, String> lowerHyphenToLowerCamel = new HashMap<>();
+    private final Map<String, String> lowerHyphenToUpperCamel = new HashMap<>();
+    private final Map<String, String> lowerCamelToLowerHyphen = new HashMap<>();
+    private final Map<String, String> upperCamelToLowerHyphen = new HashMap<>();
+
+    CaseFormatStore(){}
+
+    /**
+     * Parses the document and creates a lower camel case string
+     * upper camel string, lower hyphen and lower camel case
+     *
+     * @param doc   Takes an xml document and adds it to the hash maps as appropriate
+     */
+    void parse(Document doc){
+
+        // Get the xml-root-element and add those nodes
+        // with the attribute name and it to the hashmaps
+        // For the attribute with name, it is going to be lower-hyphen
+        // If the attribute is javaAttribute then it will be lower camel case
+        NodeList list = doc.getElementsByTagName("xml-root-element");
+        addCaseFormatForNodesAndProperties(list, "name");
+
+        list = doc.getElementsByTagName("xml-element");
+        addCaseFormatForNodesAndProperties(list, "java-attribute");
+
+        list = doc.getElementsByTagName("xml-any-element");
+        addCaseFormatForNodesAndProperties(list, "java-attribute");
+    }
+
+    private void addCaseFormatForNodesAndProperties(NodeList list, String attributeName) {
+        for (int i = 0; i < list.getLength(); i++) {
+
+            String lowerCamel = null;
+            String lowerHyphen = null;
+
+            if ("java-attribute".equals(attributeName)) {
+                lowerCamel = list.item(i).getAttributes().getNamedItem(attributeName).getNodeValue();
+                lowerHyphen = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, lowerCamel);
+            } else {
+                lowerHyphen = list.item(i).getAttributes().getNamedItem(attributeName).getNodeValue();
+                lowerCamel = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, lowerHyphen);
+            }
+
+            String upperCamel = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, lowerHyphen);
+            lowerHyphenToLowerCamel.put(lowerHyphen, lowerCamel);
+            lowerHyphenToUpperCamel.put(lowerHyphen, upperCamel);
+            upperCamelToLowerHyphen.put(upperCamel, lowerHyphen);
+            lowerCamelToLowerHyphen.put(lowerCamel, lowerHyphen);
+        }
+    }
+
+    public Optional<String> fromLowerHyphenToLowerCamel(String value){
+        return Optional.ofNullable(lowerHyphenToLowerCamel.get(value));
+    }
+
+    public Optional<String> fromLowerHyphenToUpperCamel(String value){
+        return Optional.ofNullable(lowerHyphenToUpperCamel.get(value));
+    }
+
+    public Optional<String> fromUpperCamelToLowerHyphen(String value){
+        return Optional.ofNullable(upperCamelToLowerHyphen.get(value));
+    }
+
+    public Optional<String> fromLowerCamelToLowerHyphen(String value){
+        return Optional.ofNullable(lowerCamelToLowerHyphen.get(value));
+    }
+
+}
diff --git a/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java
index f9b23080..2428a6dd 100644
--- a/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java
+++ b/aai-schema-ingest/src/main/java/org/onap/aai/nodes/NodeIngestor.java
@@ -62,14 +62,14 @@ public class NodeIngestor {
 
     private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(NodeIngestor.class);
     private static final Pattern classNamePattern = Pattern.compile("\\.(v\\d+)\\.");
-    Map<SchemaVersion, List<String>> filesToIngest;
-    private Map<SchemaVersion, DynamicJAXBContext> versionContextMap = new TreeMap<>();
-    private Map<SchemaVersion, Set<String>> typesPerVersion = new TreeMap<>();
-    private Map<SchemaVersion, Document> schemaPerVersion = new TreeMap<>();
+    private Map<SchemaVersion, DynamicJAXBContext> versionContextMap = new HashMap<>();
+    private Map<SchemaVersion, Set<String>> typesPerVersion = new HashMap<>();
+    private Map<SchemaVersion, Document> schemaPerVersion = new HashMap<>();
     private String localSchema;
     private SchemaVersions schemaVersions;
     private Set<Translator> translators;
-    
+
+    private CaseFormatStore caseFormatStore;
     //TODO : See if you can get rid of InputStream resets
 
     /**
@@ -80,6 +80,7 @@ public class NodeIngestor {
      @Autowired
     public NodeIngestor(Set<Translator> translatorSet) {
         this.translators = translatorSet;
+        this.caseFormatStore = new CaseFormatStore();
     }
 
     @PostConstruct
@@ -126,7 +127,7 @@ public class NodeIngestor {
 
                 final DynamicJAXBContext ctx = ingest(inputStreams);
                 versionContextMap.put(version, ctx);
-                typesPerVersion.put(version, getAllNodeTypes(inputStreams));
+                setAllTypesAndProperties(version, inputStreams);
                 schemaPerVersion.put(version, createCombinedSchema(inputStreams, version, retrieveLocalSchema));
             }
         } catch (JAXBException | ParserConfigurationException | SAXException | IOException e) {
@@ -150,8 +151,7 @@ public class NodeIngestor {
         return DynamicJAXBContextFactory.createContextFromOXM(this.getClass().getClassLoader(), properties);
     }
 
-    private Set<String> getAllNodeTypes(List<InputStream> inputStreams) throws ParserConfigurationException, SAXException, IOException {
-        //Reset the InputStream to reset the offset to inital position
+    private void setAllTypesAndProperties(SchemaVersion version, List<InputStream> inputStreams) throws ParserConfigurationException, IOException, SAXException {
         Set<String> types = new HashSet<>();
         final DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
         docFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
@@ -162,15 +162,20 @@ public class NodeIngestor {
             inputStream.reset();
             final Document doc = docBuilder.parse(inputStream);
             final NodeList list = doc.getElementsByTagName("java-type");
-
-            for (int i = 0; i < list.getLength(); i++) {
-                String type = list.item(i).getAttributes().getNamedItem("name").getNodeValue();
-                types.add(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, type));
-            }
+            getAllNodeTypes(list, types);
+            caseFormatStore.parse(doc);
         }
 
-        LOGGER.debug("Types size" + types.size());
-        return types;
+        LOGGER.debug("Types size {}", types.size());
+        typesPerVersion.put(version, types);
+    }
+
+    private void getAllNodeTypes(NodeList list, Set<String> types){
+
+        for (int i = 0; i < list.getLength(); i++) {
+            String type = list.item(i).getAttributes().getNamedItem("name").getNodeValue();
+            types.add(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, type));
+        }
     }
 
     private Document createCombinedSchema(List<InputStream> inputStreams, SchemaVersion version, boolean localSchema) throws ParserConfigurationException, SAXException, IOException {
@@ -272,4 +277,8 @@ public class NodeIngestor {
             "</xml-bindings>";
         return new ByteArrayInputStream(source.getBytes(StandardCharsets.UTF_8));
     }
+
+    public CaseFormatStore getCaseFormatStore(){
+        return caseFormatStore;
+    }
 }
diff --git a/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java b/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java
index a1a40e69..8143b5e1 100644
--- a/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java
+++ b/aai-schema-ingest/src/main/java/org/onap/aai/setup/SchemaVersion.java
@@ -21,20 +21,23 @@ package org.onap.aai.setup;
 
 import org.onap.aai.validation.AAISchemaValidationException;
 
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 public class SchemaVersion implements Comparable<SchemaVersion> {
 
-    public static final Pattern VERSION_PATTERN = Pattern.compile("v[1-9][0-9]*");
+    public static final Pattern VERSION_PATTERN = Pattern.compile("v([1-9][0-9]*)");
 
-    private final String value;
+    private final Integer value;
 
     public SchemaVersion(String value){
-        if(!VERSION_PATTERN.matcher(value).matches()){
+        Matcher matcher = VERSION_PATTERN.matcher(value);
+
+        if(!matcher.find()){
             throw new AAISchemaValidationException("Invalid Schema Version " + value + ", value doesn't match the expected regex: " + VERSION_PATTERN);
+        } else {
+            this.value = Integer.parseInt(matcher.group(1));
         }
-
-        this.value = value;
     }
 
     @Override
@@ -44,6 +47,7 @@ public class SchemaVersion implements Comparable<SchemaVersion> {
 
     @Override
     public boolean equals(Object other){
+
         if(this == other){
             return true;
         }
@@ -62,7 +66,7 @@ public class SchemaVersion implements Comparable<SchemaVersion> {
 
     @Override
     public String toString(){
-        return value;
+        return String.valueOf("v" + value);
     }
 
     @Override
@@ -72,12 +76,6 @@ public class SchemaVersion implements Comparable<SchemaVersion> {
             return -1;
         }
 
-        // Requires to convert to integer to match the past behavior
-        // Otherwise the string comparison of versions aren't working as expected
-
-        Integer tVal = Integer.parseInt(this.value.replaceAll("v", ""));
-        Integer oVal = Integer.parseInt(o.value.replaceAll("v", ""));
-
-        return tVal.compareTo(oVal);
+        return this.value.compareTo(o.value);
     }
 }