ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-04-13 14:13:26 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

CORDA-539 - Code Cleanup

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

Remove some IntelliJ warnings
This commit is contained in:
Katelyn Baker 2017-09-11 12:51:48 +01:00
parent c48a37a080
commit 063771fac4
6 changed files with 49 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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]!!
}
@ -242,7 +242,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
visitFieldInsn(GETFIELD, schema.jvmName, name, type.descriptor)
when (type.field) {
java.lang.Boolean.TYPE, Integer.TYPE, java.lang.Short.TYPE, java.lang.Byte.TYPE,
java.lang.Character.TYPE -> visitInsn(IRETURN)
java.lang.Character.TYPE -> visitInsn(IRETURN)
java.lang.Long.TYPE -> visitInsn(LRETURN)
java.lang.Double.TYPE -> visitInsn(DRETURN)
java.lang.Float.TYPE -> visitInsn(FRETURN)
@ -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()
}
@ -375,7 +375,7 @@ class ClassCarpenter(cl: ClassLoader = Thread.currentThread().contextClassLoader
private fun MethodVisitor.load(slot: Int, type: Field): Int {
when (type.field) {
java.lang.Boolean.TYPE, Integer.TYPE, java.lang.Short.TYPE, java.lang.Byte.TYPE,
java.lang.Character.TYPE -> visitVarInsn(ILOAD, slot)
java.lang.Character.TYPE -> visitVarInsn(ILOAD, slot)
java.lang.Long.TYPE -> visitVarInsn(LLOAD, slot)
java.lang.Double.TYPE -> visitVarInsn(DLOAD, slot)
java.lang.Float.TYPE -> visitVarInsn(FLOAD, slot)
@ -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)
}
}

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

@ -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) :
Exception ("Class $name is loadable yet contains field $field of unknown type $type")
class UncarpentableException(name: String, field: String, type: String) :
Exception("Class $name is loadable yet contains field $field of unknown type $type")

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

@ -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(
mutableListOf<Schema>(),
mutableMapOf<String, Pair<TypeNotation, MutableList<String>>>(),
mutableMapOf<String, MutableList<String>>())
return CarpenterSchemas(mutableListOf(), mutableMapOf(), mutableMapOf())
}
}
fun addDepPair(type: TypeNotation, dependant: String, dependee: String) {
dependsOn.computeIfAbsent(dependee, { mutableListOf<String>() }).add(dependant)
dependencies.computeIfAbsent(dependant, { Pair(type, mutableListOf<String>()) }).second.add(dependee)
dependsOn.computeIfAbsent(dependee, { mutableListOf() }).add(dependant)
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) {
(schemas.dependencies.remove (dependent)?.first as CompositeType).carpenterSchema (
if (schemas.dependencies[dependent]?.second?.isEmpty() == true) {
(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
get() = cc.classloader
val classloader: ClassLoader
get() = cc.classloader
}
class MetaCarpenter(schemas : CarpenterSchemas,
cc : ClassCarpenter = ClassCarpenter()) : MetaCarpenterBase(schemas, cc) {
class MetaCarpenter(schemas: CarpenterSchemas,
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,
cc : ClassCarpenter = ClassCarpenter()) : MetaCarpenterBase(schemas, cc) {
class TestMetaCarpenter(schemas: CarpenterSchemas,
cc: ClassCarpenter = ClassCarpenter()) : MetaCarpenterBase(schemas, cc) {
override fun build() {
if (schemas.carpenterSchemas.isEmpty()) return
step (schemas.carpenterSchemas.removeAt(0))
step(schemas.carpenterSchemas.removeAt(0))
}
}

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

@ -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
@ -54,7 +53,7 @@ class ClassSchema(
interfaces: List<Class<*>> = emptyList()
) : Schema(name, fields, superclass, interfaces, { name, field -> field.name = name }) {
override fun generateFields(cw: ClassWriter) {
cw.apply { fields.forEach { it.value.generateField(this) } }
cw.apply { fields.forEach { it.value.generateField(this) } }
}
}
@ -69,7 +68,7 @@ class InterfaceSchema(
interfaces: List<Class<*>> = emptyList()
) : Schema(name, fields, superclass, interfaces, { name, field -> field.name = name }) {
override fun generateFields(cw: ClassWriter) {
cw.apply { fields.forEach { it.value.generateField(this) } }
cw.apply { fields.forEach { it.value.generateField(this) } }
}
}
@ -80,8 +79,8 @@ class EnumSchema(
name: String,
fields: Map<String, Field>
) : Schema(name, fields, null, emptyList(), { fieldName, field ->
(field as EnumField).name = fieldName
field.descriptor = "L${name.replace(".", "/")};"
(field as EnumField).name = fieldName
field.descriptor = "L${name.replace(".", "/")};"
}) {
override fun generateFields(cw: ClassWriter) {
with(cw) {
@ -104,8 +103,8 @@ object CarpenterSchemaFactory {
superclass: Schema? = null,
interfaces: List<Class<*>> = emptyList(),
isInterface: Boolean = false
) : Schema =
if (isInterface) InterfaceSchema (name, fields, superclass, interfaces)
else ClassSchema (name, fields, superclass, interfaces)
): Schema =
if (isInterface) InterfaceSchema(name, fields, superclass, interfaces)
else ClassSchema(name, fields, superclass, interfaces)
}

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

@ -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) {
override var descriptor : String? = null
class EnumField : Field(Enum::class.java) {
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?>) =
if (mandatory) NonNullableField (name, field) else NullableField (name, field)
fun newInstance(mandatory: Boolean, name: String, field: Class<out Any?>) =
if (mandatory) NonNullableField(name, field) else NullableField(name, field)
}

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

@ -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") as Enum<*>).name)
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)
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)))