From 28b7610e47ae4225bf531f5d4b76acb1352adb2b Mon Sep 17 00:00:00 2001 From: Katelyn Baker Date: Fri, 23 Jun 2017 09:02:00 +0100 Subject: [PATCH] IntelliJ reformat of the code --- .../net/corda/carpenter/ClassCarpenter.kt | 53 +++++++------- .../net/corda/carpenter/ClassCarpenterTest.kt | 72 +++++++++---------- 2 files changed, 63 insertions(+), 62 deletions(-) diff --git a/experimental/src/main/kotlin/net/corda/carpenter/ClassCarpenter.kt b/experimental/src/main/kotlin/net/corda/carpenter/ClassCarpenter.kt index 983b31c248..534083325f 100644 --- a/experimental/src/main/kotlin/net/corda/carpenter/ClassCarpenter.kt +++ b/experimental/src/main/kotlin/net/corda/carpenter/ClassCarpenter.kt @@ -76,27 +76,27 @@ class ClassCarpenter { val descriptors = fields.map { it.key to Type.getDescriptor(it.value) }.toMap() fun fieldsIncludingSuperclasses(): Map> = (superclass?.fieldsIncludingSuperclasses() ?: emptyMap()) + LinkedHashMap(fields) - fun descriptorsIncludingSuperclasses(): Map = (superclass?.descriptorsIncludingSuperclasses() ?: emptyMap()) + LinkedHashMap(descriptors) + fun descriptorsIncludingSuperclasses(): Map = (superclass?.descriptorsIncludingSuperclasses() ?: emptyMap()) + LinkedHashMap(descriptors) - val jvmName : String - get() = name.replace (".", "/") + val jvmName: String + get() = name.replace(".", "/") } private val String.jvm: String get() = replace(".", "/") class ClassSchema( - name: String, - fields: Map>, - superclass: Schema? = null, - interfaces: List> = emptyList() - ) : Schema (name, fields, superclass, interfaces) + name: String, + fields: Map>, + superclass: Schema? = null, + interfaces: List> = emptyList() + ) : Schema(name, fields, superclass, interfaces) class InterfaceSchema( - name: String, - fields: Map>, - superclass: Schema? = null, - interfaces: List> = emptyList() - ) : Schema (name, fields, superclass, interfaces) + name: String, + fields: Map>, + superclass: Schema? = null, + interfaces: List> = emptyList() + ) : Schema(name, fields, superclass, interfaces) class DuplicateName : RuntimeException("An attempt was made to register two classes with the same name within the same ClassCarpenter namespace.") class InterfaceMismatch(msg: String) : RuntimeException(msg) @@ -104,6 +104,7 @@ class ClassCarpenter { private class CarpenterClassLoader : ClassLoader(Thread.currentThread().contextClassLoader) { fun load(name: String, bytes: ByteArray) = defineClass(name, bytes, 0, bytes.size) } + private val classloader = CarpenterClassLoader() private val _loaded = HashMap>() @@ -132,18 +133,18 @@ class ClassCarpenter { hierarchy.reversed().forEach { when (it) { is InterfaceSchema -> generateInterface(it) - is ClassSchema -> generateClass(it) + is ClassSchema -> generateClass(it) } } return _loaded[schema.name]!! } - private fun generateInterface (schema: Schema): Class<*> { - return generate (schema) { cw, schema -> + private fun generateInterface(schema: Schema): Class<*> { + return generate(schema) { cw, schema -> val interfaces = schema.interfaces.map { it.name.jvm }.toTypedArray() - with (cw) { + with(cw) { visit(V1_8, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE, schema.jvmName, null, "java/lang/Object", interfaces) generateAbstractGetters(schema) @@ -153,12 +154,12 @@ class ClassCarpenter { } } - private fun generateClass (schema: Schema): Class<*> { - return generate (schema) { cw, schema -> - val superName = schema.superclass?.jvmName ?: "java/lang/Object" + private fun generateClass(schema: Schema): Class<*> { + return generate(schema) { cw, schema -> + val superName = schema.superclass?.jvmName ?: "java/lang/Object" val interfaces = arrayOf(SimpleFieldAccess::class.java.name.jvm) + schema.interfaces.map { it.name.jvm } - with (cw) { + with(cw) { visit(V1_8, ACC_PUBLIC + ACC_SUPER, schema.jvmName, null, superName, interfaces) generateFields(schema) @@ -173,11 +174,11 @@ class ClassCarpenter { } } - private fun generate(schema: Schema, generator : (ClassWriter, Schema) -> Unit): Class<*> { + private fun generate(schema: Schema, generator: (ClassWriter, Schema) -> Unit): Class<*> { // Lazy: we could compute max locals/max stack ourselves, it'd be faster. - val cw = ClassWriter (ClassWriter.COMPUTE_FRAMES or ClassWriter.COMPUTE_MAXS) + val cw = ClassWriter(ClassWriter.COMPUTE_FRAMES or ClassWriter.COMPUTE_MAXS) - generator (cw, schema) + generator(cw, schema) val clazz = classloader.load(schema.name, cw.toByteArray()) _loaded[schema.name] = clazz @@ -252,8 +253,8 @@ class ClassCarpenter { private fun ClassWriter.generateAbstractGetters(schema: Schema) { for ((name, _) in schema.fields) { val descriptor = schema.descriptors[name] - val opcodes = ACC_ABSTRACT + ACC_PUBLIC - with (visitMethod(opcodes, "get" + name.capitalize(), "()" + descriptor, null, null)) { + val opcodes = ACC_ABSTRACT + ACC_PUBLIC + with(visitMethod(opcodes, "get" + name.capitalize(), "()" + descriptor, null, null)) { // abstract method doesn't have any implementation so just end visitEnd() } diff --git a/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTest.kt b/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTest.kt index 27fe55ea2d..1827c83d79 100644 --- a/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTest.kt +++ b/experimental/src/test/kotlin/net/corda/carpenter/ClassCarpenterTest.kt @@ -143,9 +143,9 @@ class ClassCarpenterTest { assertEquals(iface.declaredMethods[0].name, "getA") val schema2 = ClassCarpenter.ClassSchema("gen.Derived", mapOf("a" to Int::class.java), interfaces = listOf(iface)) - val clazz = cc.build(schema2) - val testA = 42 - val i = clazz.constructors[0].newInstance(testA) as SimpleFieldAccess + val clazz = cc.build(schema2) + val testA = 42 + val i = clazz.constructors[0].newInstance(testA) as SimpleFieldAccess assertEquals(testA, i["a"]) } @@ -156,20 +156,20 @@ class ClassCarpenterTest { val iFace2 = ClassCarpenter.InterfaceSchema("gen.Interface2", mapOf("c" to Int::class.java, "d" to String::class.java)) val class1 = ClassCarpenter.ClassSchema( - "gen.Derived", - mapOf( - "a" to Int::class.java, - "b" to String::class.java, - "c" to Int::class.java, - "d" to String::class.java), - interfaces = listOf(cc.build(iFace1), cc.build(iFace2))) + "gen.Derived", + mapOf( + "a" to Int::class.java, + "b" to String::class.java, + "c" to Int::class.java, + "d" to String::class.java), + interfaces = listOf(cc.build(iFace1), cc.build(iFace2))) val clazz = cc.build(class1) - val testA = 42 - val testB = "don't touch me, I'm scared" - val testC = 0xDEAD - val testD = "wibble" - val i = clazz.constructors[0].newInstance(testA, testB, testC, testD) as SimpleFieldAccess + val testA = 42 + val testB = "don't touch me, I'm scared" + val testC = 0xDEAD + val testD = "wibble" + val i = clazz.constructors[0].newInstance(testA, testB, testC, testD) as SimpleFieldAccess assertEquals(testA, i["a"]) assertEquals(testB, i["b"]) @@ -180,33 +180,33 @@ class ClassCarpenterTest { @Test fun `interface implementing interface`() { val iFace1 = ClassCarpenter.InterfaceSchema( - "gen.Interface1", - mapOf( - "a" to Int::class.java, - "b" to String::class.java)) + "gen.Interface1", + mapOf( + "a" to Int::class.java, + "b" to String::class.java)) val iFace2 = ClassCarpenter.InterfaceSchema( - "gen.Interface2", - mapOf( - "c" to Int::class.java, - "d" to String::class.java), - interfaces = listOf(cc.build(iFace1))) + "gen.Interface2", + mapOf( + "c" to Int::class.java, + "d" to String::class.java), + interfaces = listOf(cc.build(iFace1))) val class1 = ClassCarpenter.ClassSchema( - "gen.Derived", - mapOf( - "a" to Int::class.java, - "b" to String::class.java, - "c" to Int::class.java, - "d" to String::class.java), - interfaces = listOf(cc.build(iFace2))) + "gen.Derived", + mapOf( + "a" to Int::class.java, + "b" to String::class.java, + "c" to Int::class.java, + "d" to String::class.java), + interfaces = listOf(cc.build(iFace2))) val clazz = cc.build(class1) - val testA = 99 - val testB = "green is not a creative colour" - val testC = 7 - val testD = "I like jam" - val i = clazz.constructors[0].newInstance(testA, testB, testC, testD) as SimpleFieldAccess + val testA = 99 + val testB = "green is not a creative colour" + val testC = 7 + val testD = "I like jam" + val i = clazz.constructors[0].newInstance(testA, testB, testC, testD) as SimpleFieldAccess assertEquals(testA, i["a"]) assertEquals(testB, i["b"])