CORDA-539 - Code Cleanup

Applying IntelliJ's white space reformat as no doubt I didn't follow the
coding convention too closely.

Remove some IntelliJ warnings

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/ClassCarpenter.kt

@@ -20,7 +20,7 @@ interface SimpleFieldAccess {
     operator fun get(name: String): Any?
 }
 
-class CarpenterClassLoader (parentClassLoader: ClassLoader = Thread.currentThread().contextClassLoader) :
+class CarpenterClassLoader(parentClassLoader: ClassLoader = Thread.currentThread().contextClassLoader) :
         ClassLoader(parentClassLoader) {
     fun load(name: String, bytes: ByteArray) = defineClass(name, bytes, 0, bytes.size)
 }
@@ -121,7 +121,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
             }
         }
 
-        assert (schema.name in _loaded)
+        assert(schema.name in _loaded)
 
         return _loaded[schema.name]!!
     }
@@ -286,7 +286,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
             visitFieldInsn(PUTSTATIC, schema.jvmName, "\$VALUES", schema.asArray)
             visitInsn(RETURN)
 
-            visitMaxs(0,0)
+            visitMaxs(0, 0)
         }.visitEnd()
     }
 
@@ -419,7 +419,8 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
     }
 
     companion object {
-        @JvmStatic @Suppress("UNUSED")
+        @JvmStatic
+        @Suppress("UNUSED")
         fun getField(obj: Any, name: String): Any? = obj.javaClass.getMethod("get" + name.capitalize()).invoke(obj)
     }
 }

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Exceptions.kt

@@ -1,11 +1,11 @@
 package net.corda.nodeapi.internal.serialization.carpenter
 
-class DuplicateNameException : RuntimeException (
+class DuplicateNameException : RuntimeException(
         "An attempt was made to register two classes with the same name within the same ClassCarpenter namespace.")
 
 class InterfaceMismatchException(msg: String) : RuntimeException(msg)
 
 class NullablePrimitiveException(msg: String) : RuntimeException(msg)
 
-class UncarpentableException (name: String, field: String, type: String) :
+class UncarpentableException(name: String, field: String, type: String) :
-        Exception ("Class $name is loadable yet contains field $field of unknown type $type")
+        Exception("Class $name is loadable yet contains field $field of unknown type $type")

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/MetaCarpenter.kt

@@ -22,22 +22,19 @@ import net.corda.nodeapi.internal.serialization.amqp.TypeNotation
  * in turn look up all of those classes in the [dependsOn] list, remove their dependency on the newly created class,
  * and if that list is reduced to zero know we can now generate a [Schema] for them and carpent them up
  */
-data class CarpenterSchemas (
+data class CarpenterSchemas(
         val carpenterSchemas: MutableList<Schema>,
         val dependencies: MutableMap<String, Pair<TypeNotation, MutableList<String>>>,
         val dependsOn: MutableMap<String, MutableList<String>>) {
     companion object CarpenterSchemaConstructor {
         fun newInstance(): CarpenterSchemas {
-            return CarpenterSchemas(
+            return CarpenterSchemas(mutableListOf(), mutableMapOf(), mutableMapOf())
-                    mutableListOf<Schema>(),
-                    mutableMapOf<String, Pair<TypeNotation, MutableList<String>>>(),
-                    mutableMapOf<String, MutableList<String>>())
         }
     }
 
     fun addDepPair(type: TypeNotation, dependant: String, dependee: String) {
-        dependsOn.computeIfAbsent(dependee, { mutableListOf<String>() }).add(dependant)
+        dependsOn.computeIfAbsent(dependee, { mutableListOf() }).add(dependant)
-        dependencies.computeIfAbsent(dependant, { Pair(type, mutableListOf<String>()) }).second.add(dependee)
+        dependencies.computeIfAbsent(dependant, { Pair(type, mutableListOf()) }).second.add(dependee)
     }
 
     val size
@@ -56,23 +53,23 @@ data class CarpenterSchemas (
  * @property cc a reference to the actual class carpenter we're using to constuct classes
  * @property objects a list of carpented classes loaded into the carpenters class loader
  */
-abstract class MetaCarpenterBase (val schemas : CarpenterSchemas, val cc : ClassCarpenter = ClassCarpenter()) {
+abstract class MetaCarpenterBase(val schemas: CarpenterSchemas, val cc: ClassCarpenter = ClassCarpenter()) {
     val objects = mutableMapOf<String, Class<*>>()
 
     fun step(newObject: Schema) {
-        objects[newObject.name] = cc.build (newObject)
+        objects[newObject.name] = cc.build(newObject)
 
         // go over the list of everything that had a dependency on the newly
         // carpented class existing and remove it from their dependency list, If that
         // list is now empty we have no impediment to carpenting that class up
         schemas.dependsOn.remove(newObject.name)?.forEach { dependent ->
-            assert (newObject.name in schemas.dependencies[dependent]!!.second)
+            assert(newObject.name in schemas.dependencies[dependent]!!.second)
 
             schemas.dependencies[dependent]?.second?.remove(newObject.name)
 
             // we're out of blockers so  we can now create the type
-            if (schemas.dependencies[dependent]?.second?.isEmpty() ?: false) {
+            if (schemas.dependencies[dependent]?.second?.isEmpty() == true) {
-                (schemas.dependencies.remove (dependent)?.first as CompositeType).carpenterSchema (
+                (schemas.dependencies.remove(dependent)?.first as CompositeType).carpenterSchema(
                         classloader = cc.classloader,
                         carpenterSchemas = schemas)
             }
@@ -81,25 +78,25 @@ abstract class MetaCarpenterBase (val schemas : CarpenterSchemas, val cc : Class
 
     abstract fun build()
 
-    val classloader : ClassLoader
+    val classloader: ClassLoader
         get() = cc.classloader
 }
 
-class MetaCarpenter(schemas : CarpenterSchemas,
+class MetaCarpenter(schemas: CarpenterSchemas,
-                    cc : ClassCarpenter = ClassCarpenter()) : MetaCarpenterBase(schemas, cc) {
+                    cc: ClassCarpenter = ClassCarpenter()) : MetaCarpenterBase(schemas, cc) {
     override fun build() {
         while (schemas.carpenterSchemas.isNotEmpty()) {
             val newObject = schemas.carpenterSchemas.removeAt(0)
-            step (newObject)
+            step(newObject)
         }
     }
 }
 
-class TestMetaCarpenter(schemas : CarpenterSchemas,
+class TestMetaCarpenter(schemas: CarpenterSchemas,
-                        cc : ClassCarpenter = ClassCarpenter()) : MetaCarpenterBase(schemas, cc) {
+                        cc: ClassCarpenter = ClassCarpenter()) : MetaCarpenterBase(schemas, cc) {
     override fun build() {
         if (schemas.carpenterSchemas.isEmpty()) return
-        step (schemas.carpenterSchemas.removeAt(0))
+        step(schemas.carpenterSchemas.removeAt(0))
     }
 }
 

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/Schema.kt

@@ -17,12 +17,11 @@ abstract class Schema(
         var fields: Map<String, Field>,
         val superclass: Schema? = null,
         val interfaces: List<Class<*>> = emptyList(),
-        updater : (String, Field) -> Unit)
+        updater: (String, Field) -> Unit) {
-{
     private fun Map<String, Field>.descriptors() = LinkedHashMap(this.mapValues { it.value.descriptor })
 
     init {
-        fields.forEach { updater (it.key, it.value) }
+        fields.forEach { updater(it.key, it.value) }
 
         // Fix the order up front if the user didn't, inject the name into the field as it's
         // neater when iterating
@@ -104,8 +103,8 @@ object CarpenterSchemaFactory {
             superclass: Schema? = null,
             interfaces: List<Class<*>> = emptyList(),
             isInterface: Boolean = false
-    ) : Schema =
+    ): Schema =
-            if (isInterface) InterfaceSchema (name, fields, superclass, interfaces)
+            if (isInterface) InterfaceSchema(name, fields, superclass, interfaces)
-            else ClassSchema (name, fields, superclass, interfaces)
+            else ClassSchema(name, fields, superclass, interfaces)
 }
 

node-api/src/main/kotlin/net/corda/nodeapi/internal/serialization/carpenter/SchemaFields.kt

@@ -96,7 +96,7 @@ class NullableField(field: Class<out Any?>) : ClassField(field) {
 
     constructor(name: String, field: Class<out Any?>) : this(field) {
         if (field.isPrimitive) {
-            throw NullablePrimitiveException (
+            throw NullablePrimitiveException(
                     "Field $name is primitive type ${Type.getDescriptor(field)} and thus cannot be nullable")
         }
 
@@ -111,8 +111,8 @@ class NullableField(field: Class<out Any?>) : ClassField(field) {
 /**
  * Represents enum constants within an enum
  */
-class EnumField: Field(Enum::class.java) {
+class EnumField : Field(Enum::class.java) {
-    override var descriptor : String? = null
+    override var descriptor: String? = null
 
     override val type: String
         get() = "Ljava/lang/Enum;"
@@ -132,7 +132,7 @@ class EnumField: Field(Enum::class.java) {
  * the AMQP schema indicates it's mandatory (non nullable) or not (nullable)
  */
 object FieldFactory {
-    fun newInstance (mandatory: Boolean, name: String, field: Class<out Any?>) =
+    fun newInstance(mandatory: Boolean, name: String, field: Class<out Any?>) =
-            if (mandatory) NonNullableField (name, field) else NullableField (name, field)
+            if (mandatory) NonNullableField(name, field) else NullableField(name, field)
 
 }

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/carpenter/EnumClassTests.kt

@@ -8,7 +8,7 @@ class EnumClassTests : AmqpCarpenterBase() {
 
     @Test
     fun oneValue() {
-        val enumConstants = mapOf ("A" to EnumField())
+        val enumConstants = mapOf("A" to EnumField())
 
         val schema = EnumSchema("gen.enum", enumConstants)
 
@@ -17,7 +17,7 @@ class EnumClassTests : AmqpCarpenterBase() {
 
     @Test
     fun oneValueInstantiate() {
-        val enumConstants = mapOf ("A" to EnumField())
+        val enumConstants = mapOf("A" to EnumField())
         val schema = EnumSchema("gen.enum", enumConstants)
         val clazz = cc.build(schema)
 
@@ -30,7 +30,7 @@ class EnumClassTests : AmqpCarpenterBase() {
 
     @Test
     fun twoValuesInstantiate() {
-        val enumConstants = mapOf ("left" to EnumField(), "right" to EnumField())
+        val enumConstants = mapOf("left" to EnumField(), "right" to EnumField())
         val schema = EnumSchema("gen.enum", enumConstants)
         val clazz = cc.build(schema)
 
@@ -70,12 +70,12 @@ class EnumClassTests : AmqpCarpenterBase() {
         val schema = EnumSchema("gen.enum", enumConstants)
         val clazz = cc.build(schema)
 
-        assertEquals("CCC", clazz.getMethod("valueOf", String::class.java).invoke (null, "CCC").toString())
+        assertEquals("CCC", clazz.getMethod("valueOf", String::class.java).invoke(null, "CCC").toString())
-        assertEquals("CCC", (clazz.getMethod("valueOf", String::class.java).invoke (null, "CCC") as Enum<*>).name)
+        assertEquals("CCC", (clazz.getMethod("valueOf", String::class.java).invoke(null, "CCC") as Enum<*>).name)
 
-        val ddd = clazz.getMethod("valueOf", String::class.java).invoke (null, "DDD") as Enum<*>
+        val ddd = clazz.getMethod("valueOf", String::class.java).invoke(null, "DDD") as Enum<*>
 
-        assertTrue (ddd::class.java.isEnum)
+        assertTrue(ddd::class.java.isEnum)
         assertEquals("DDD", ddd.name)
         assertEquals(3, ddd.ordinal)
     }
@@ -91,7 +91,7 @@ class EnumClassTests : AmqpCarpenterBase() {
 
         val enumClazz = cc2.build(schema1)
 
-        val schema2 = ClassSchema ("gen.class",
+        val schema2 = ClassSchema("gen.class",
                 mapOf(
                         "a" to NonNullableField(Int::class.java),
                         "b" to NonNullableField(enumClazz)))