use interface to replace instanceof code

Author: hauner

src/main/groovy/com/github/hauner/openapi/spring/converter/DataTypeMapper.groovy

@@ -17,11 +17,9 @@
 package com.github.hauner.openapi.spring.converter
 
 import com.github.hauner.openapi.spring.converter.mapping.AmbiguousTypeMappingException
-import com.github.hauner.openapi.spring.converter.mapping.EndpointTypeMapping
-import com.github.hauner.openapi.spring.converter.mapping.ParameterTypeMapping
-import com.github.hauner.openapi.spring.converter.mapping.ResponseTypeMapping
 import com.github.hauner.openapi.spring.converter.mapping.TargetType
 import com.github.hauner.openapi.spring.converter.mapping.TypeMapping
+import com.github.hauner.openapi.spring.converter.mapping.TypeMappingX
 import com.github.hauner.openapi.spring.converter.schema.SchemaType
 
 /**
@@ -31,66 +29,44 @@ import com.github.hauner.openapi.spring.converter.schema.SchemaType
  */
 class DataTypeMapper {
 
-    private List<?> typeMappings
+    private List<TypeMappingX> typeMappings
 
     DataTypeMapper(List<?> typeMappings) {
-        this.typeMappings = typeMappings ?: []
+        this.typeMappings = (typeMappings ?: []) as List<TypeMappingX>
     }
 
     TargetType getMappedDataType (SchemaType schemaType) {
 
         // check endpoint mappings
-        List<?> matchesW = schemaType.findEndpointMappings (getEndpointMappings ())
-        if (!matchesW.empty) {
-            TargetType target = matchesW.first().targetType
+        List<TypeMappingX> endpointMatches = schemaType.matchEndpointMapping (typeMappings)
+        if (!endpointMatches.empty) {
+            TargetType target = endpointMatches.first().targetType
             if (target) {
                 return target
             }
         }
 
         // check global parameter & response mappings
-        List<?> matchesX = schemaType.findGlobalMappings (getGlobalMappings ())
-        if (!matchesX.empty) {
-            TargetType target = matchesX.first().targetType
+        List<TypeMappingX> ioMatches = schemaType.matchIoMapping (typeMappings)
+        if (!ioMatches.empty) {
+            TargetType target = ioMatches.first().targetType
             if (target) {
                 return target
             }
         }
 
         // check global type mapping
-        List<?> matches = schemaType.findGlobalTypeMappings (getGlobalTypeMappings ())
-        if (matches.isEmpty ()) {
+        List<TypeMappingX> typeMatches = schemaType.matchTypeMapping (typeMappings)
+        if (typeMatches.isEmpty ()) {
             return null
         }
 
-        if (matches.size () != 1) {
-            throw new AmbiguousTypeMappingException (matches)
+        if (typeMatches.size () != 1) {
+            throw new AmbiguousTypeMappingException (typeMatches)
         }
 
-        TypeMapping match = matches.first () as TypeMapping
+        TypeMapping match = typeMatches.first () as TypeMapping
         return match.targetType
     }
 
-    private List<EndpointTypeMapping> getEndpointMappings() {
-        getEndpointMappings (typeMappings)
-    }
-
-    private List<?> getGlobalMappings () {
-        typeMappings.findResults {
-            it instanceof ParameterTypeMapping || it instanceof ResponseTypeMapping ? it : null
-        }
-    }
-
-    private List<EndpointTypeMapping> getEndpointMappings (List<?> typeMappings) {
-        typeMappings.findResults {
-            it instanceof EndpointTypeMapping ? it : null
-        }
-    }
-
-    private List<TypeMapping> getGlobalTypeMappings () {
-        typeMappings.findResults {
-            it instanceof TypeMapping ? it : null
-        }
-    }
-
 }

src/main/groovy/com/github/hauner/openapi/spring/converter/mapping/EndpointTypeMapping.groovy

@@ -50,8 +50,19 @@ class EndpointTypeMapping implements TypeMappingX {
      * @param info the schema info
      * @return true, if path is equal, false if not
      */
+    @Override
     boolean matches (SchemaInfo info) {
         path == info.path
     }
 
+    @Override
+    boolean isLevel (MappingLevel level) {
+        MappingLevel.ENDPOINT == level
+    }
+
+    @Override
+    List<TypeMappingX> getChildMappings () {
+        typeMappings
+    }
+
 }

src/main/groovy/com/github/hauner/openapi/spring/converter/mapping/ParameterTypeMapping.groovy

@@ -43,6 +43,7 @@ class ParameterTypeMapping implements TypeMappingX {
      * @param info a parameter schema info
      * @return true if it is a mapping for info, else false
      */
+    @Override
     boolean matches (SchemaInfo info) {
         if (! (info instanceof ParameterSchemaInfo)) {
             return false
@@ -51,4 +52,14 @@ class ParameterTypeMapping implements TypeMappingX {
         parameterName == info.name
     }
 
+    @Override
+    boolean isLevel (MappingLevel level) {
+        MappingLevel.IO == level
+    }
+
+    @Override
+    List<TypeMappingX> getChildMappings () {
+        [mapping]
+    }
+
 }

src/main/groovy/com/github/hauner/openapi/spring/converter/mapping/ResponseTypeMapping.groovy

@@ -43,6 +43,7 @@ class ResponseTypeMapping implements TypeMappingX {
      * @param info a response schema info
      * @return true if it is a mapping for info, else false
      */
+    @Override
     boolean matches (SchemaInfo info) {
         if (! (info instanceof ResponseSchemaInfo)) {
             return false
@@ -51,4 +52,14 @@ class ResponseTypeMapping implements TypeMappingX {
         contentType == info.contentType
     }
 
+    @Override
+    boolean isLevel (MappingLevel level) {
+        MappingLevel.IO == level
+    }
+
+    @Override
+    List<TypeMappingX> getChildMappings () {
+        [mapping]
+    }
+
 }

src/main/groovy/com/github/hauner/openapi/spring/converter/mapping/TypeMapping.groovy

@@ -61,17 +61,27 @@ class TypeMapping implements TypeMappingX {
         "$sourceTypeName" + (sourceTypeFormat ? ":$sourceTypeFormat" : "")
     }
 
-
     /**
      * Checks if it is a mapping for the given schema info
      *
      * @param info a schema info
      * @return true if it is a mapping for info, else false
      */
+    @Override
     boolean matches (SchemaInfo info) {
         sourceTypeName == info.name
     }
 
+    @Override
+    boolean isLevel (MappingLevel level) {
+        MappingLevel.TYPE == level
+    }
+
+    @Override
+    List<TypeMappingX> getChildMappings () {
+        [this]
+    }
+
     /**
      * Returns the target type of this type mapping.
      *

src/main/groovy/com/github/hauner/openapi/spring/converter/mapping/TypeMappingX.groovy

@@ -1,7 +1,35 @@
+/*
+ * Copyright 2019 the original authors
+ *
+ * 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.
+ */
+
 package com.github.hauner.openapi.spring.converter.mapping
 
 import com.github.hauner.openapi.spring.converter.schema.SchemaInfo
 
+/**
+ * Type mapping levels
+ */
+enum MappingLevel {
+    ENDPOINT, IO, TYPE
+}
+
+/**
+ *
+ */
 interface TypeMappingX {
     boolean matches (SchemaInfo info)
+    boolean isLevel (MappingLevel level)
+    List<TypeMappingX> getChildMappings ()
 }

src/main/groovy/com/github/hauner/openapi/spring/converter/schema/SchemaType.groovy

@@ -16,15 +16,15 @@
 
 package com.github.hauner.openapi.spring.converter.schema
 
-import com.github.hauner.openapi.spring.converter.mapping.EndpointTypeMapping
-import com.github.hauner.openapi.spring.converter.mapping.TypeMapping
+import com.github.hauner.openapi.spring.converter.mapping.MappingLevel
+import com.github.hauner.openapi.spring.converter.mapping.TypeMappingX
 
 
 interface SchemaType {
 
-    List<?> findEndpointMappings (List<EndpointTypeMapping> typeMappings)
-    List<?> findGlobalMappings (List<?> typeMappings)
-    List<?> findGlobalTypeMappings (List<?> typeMappings)
+    List<TypeMappingX> matchEndpointMapping (List<TypeMappingX> typeMappings)
+    List<TypeMappingX> matchIoMapping (List<TypeMappingX> typeMappings)
+    List<TypeMappingX> matchTypeMapping (List<TypeMappingX> typeMappings)
 
 }
 
@@ -37,42 +37,40 @@ abstract class SchemaTypeBase implements SchemaType {
     }
 
     @Override
-    List<?> findEndpointMappings (List<EndpointTypeMapping> typeMappings) {
-        // endpoint mappings matching by path
-        def all = typeMappings.findAll {
-            it.matches (info)
+    List<TypeMappingX> matchEndpointMapping (List<TypeMappingX> typeMappings) {
+        // mappings matching by path
+        List<TypeMappingX> endpoint = typeMappings.findAll {
+            it.isLevel (MappingLevel.ENDPOINT) && it.matches (info)
         }.collect {
-            it.typeMappings
-        }.flatten ()
+            it.childMappings
+        }.flatten () as List<TypeMappingX>
 
-        // find global parameter, response & type mappings
-        def global = all.findAll {
-            it.matches (info)
-        }
-
-        // global parameter or response mappings
-        def mappings = global.findAll {
-            ! (it instanceof TypeMapping)
+        // io mappings
+        List<TypeMappingX> io = endpoint.findAll {
+            it.isLevel (MappingLevel.IO) && it.matches (info)
         }.collect {
-            it.mapping
-        }
+            it.childMappings
+        }.flatten () as List<TypeMappingX>
 
-        if (!mappings.empty) {
-            return mappings
+        if (!io.empty) {
+            return io
         }
 
-        global.findAll {
-            it instanceof TypeMapping
-        }
+        // type mappings
+        endpoint.findAll {
+            it.isLevel (MappingLevel.TYPE) && it.matches (info)
+        }.collect {
+            it.childMappings
+        }.flatten () as List<TypeMappingX>
     }
 
-    @Override
-    List<?> findGlobalMappings (List<?> typeMappings) {
+    List<TypeMappingX> matchIoMapping (List<TypeMappingX> typeMappings) {
+        // io mappings
         typeMappings.findAll {
-            it.matches (info)
+            it.isLevel (MappingLevel.IO) && it.matches (info)
         }.collect {
-            it.mapping
-        }
+            it.childMappings
+        }.flatten () as List<TypeMappingX>
     }
 
 }
@@ -84,9 +82,9 @@ class ObjectSchemaType extends SchemaTypeBase {
     }
 
     @Override
-    List<?> findGlobalTypeMappings (List<?> typeMappings) {
+    List<TypeMappingX> matchTypeMapping (List<TypeMappingX> typeMappings) {
         typeMappings.findAll {
-            it.matches (info)
+            it.isLevel (MappingLevel.TYPE) && it.matches (info)
         }
     }
 
@@ -99,12 +97,12 @@ class ArraySchemaType extends SchemaTypeBase {
     }
 
     @Override
-    List<?> findGlobalTypeMappings (List<?> typeMappings) {
+    List<TypeMappingX> matchTypeMapping (List<TypeMappingX> typeMappings) {
         typeMappings.findAll () {
-            it.matches (new SchemaInfo (null, null,'array'))
+            it.isLevel (MappingLevel.TYPE) && it.matches (new SchemaInfo (null, null,'array'))
         }
     }
-    
+
 }