Tjyylli

I've been using my Dynamic Exception with C# for quite some time already and it saved me a lot of time. This means, I don't have to create a new exception class for each and every case. I wanted to have the same functionality on Android and in kotlin/java so I can do this:

fun main() {

    throw dynamicException("My", "Hallo exception!") // throws MyException

}

The DynamicException.kt file contains most of the code where the dynamicException function first initializes the source-code for the new exception by formatting a String then it uses the JavaCompiler to build the class and call the appropriate construtor. Either with or without the inner exception.

import java.io.File

import java.lang.reflect.Constructor

import java.net.URI

import java.net.URL

import java.net.URLClassLoader

import java.util.*

import javax.tools.DiagnosticCollector

import javax.tools.JavaFileObject

import javax.tools.SimpleJavaFileObject

import javax.tools.ToolProvider



fun dynamicException(name: String, message: String, inner: Throwable? = null): java.lang.Exception {

    val javaCompiler = ToolProvider.getSystemJavaCompiler()

    val diagnosticCollector = DiagnosticCollector<JavaFileObject>()



    val values = TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER)

    values["name"] = name

    var sourceCode = SourceCodeJavaFileObject(

        "com.he-dev.${name}Exception",

        dynamicExceptionSourceCode.smartFormat(values)

    )

    javaCompiler.getTask(

        null,

        null,

        diagnosticCollector,

        null,

        null,

        arrayListOf(sourceCode)

    ).call()



    val classLoader = URLClassLoader.newInstance(arrayOf<URL>(File("").toURI().toURL()))



    var getCtor: () -> Constructor<out Any> = {

        val cls = Class.forName("${name}Exception", true, classLoader)

        val ctor = if (inner == null) {

            cls.getConstructor(String::class.java)

        } else {

            cls.getConstructor(String::class.java, Throwable::class.java)

        }

        ctor.makeAccessible()

    }



    return if (inner == null) {

        getCtor().newInstance(message) as java.lang.Exception

    } else {

        getCtor().newInstance(message, inner) as java.lang.Exception

    }

}



fun Constructor<out Any>.makeAccessible(): Constructor<out Any> {

    this.isAccessible = true

    return this

}





val dynamicExceptionSourceCode: String = """

public class {Name}Exception extends java.lang.Exception {

    public {Name}Exception(java.lang.String message) {

        super(message);

    }

    public {Name}Exception(java.lang.String message, java.lang.Throwable inner) {

        super(message, inner);

    }

}

""".trimIndent()



class SourceCodeJavaFileObject : SimpleJavaFileObject {

    private val sourceCode: CharSequence



    constructor(className: String, sourceCode: CharSequence) :

            super(

                URI.create("string:///" + className.replace('.', '/') + JavaFileObject.Kind.SOURCE.extension),

                JavaFileObject.Kind.SOURCE

            ) {

        this.sourceCode = sourceCode

    }



    override fun getCharContent(ignoreEncodingErrors: Boolean): CharSequence {

        return sourceCode

    }

}

The string formatting is done with a string extension that can replace patterns. I based it on my C# formatter. However, it's simpler because it doesn't not support value formatting.

import java.util.*



fun String.smartFormat(values: TreeMap<String, String>): String {

    val regex = Regex("""{(?<name>[a-z][a-z0-9_.-]*)}""", RegexOption.IGNORE_CASE)

    return regex.replace(this) {

        var key = it.groups["name"]?.value

        if (values.containsKey(key)) values[key]!! else it.value

    }

}

Is there anything that can be simplified or made even cleaner?

Disclaimer: Please let's not make it about whether this utility is a good or bad practice. I've used it many projects already and it stands the test of being super-helpful and super-efficient. I can discuss it on Software Engineering if you'd like to know more but here I'm only interested in improving the code.

Is there anything that can be simplified or made even cleaner?

Yes, don't invoke the Java compiler at runtime.

From your examples in a comment:

DynamicException.Create($"ExtractMethodName(memberName)}NotSupported", ...)

From an example on your earlier post (in C#)

throw ("SettingNotFoundException", $"Setting {fullName.ToString().QuoteWith("'")} not found.").ToDynamicException())

public BackgroundImageNotFoundException(string fileName) : base($"Where is the '{fileName}' image?") { }

Replace these with:

• throw new MethodNotSupported(extractMethodName(memberName))


• throw new UnsupportedOperationError(extractMethodName(memberName))


• throw new IllegalStateException("Setting '" + fullName + "' not found")


• throw new FileNotFoundException(fileName)

If you look at the subclasses of Java's Exception or RuntimeException (many of which also has a Kotlin version) you can probably find an already existing exception that does what you need, and you just need to add a message to it.

In a chat message related to your C# post you wrote:

In order to be able to track down a bug you need two pieces of information: The name of the exception and a message. With a generic exception I could just throw an Exception but the name of the exception should already be strong enough to tell what caused it, the message is just a hint.

You should already know what happend by not even reading the message.

I completely disagree with this. The message is not just a hint. To understand fully what happened and how to reproduce it you need to read the message.

As an extra bonus, here's how you define exceptions easily in Kotlin, and the approach I would recommend:

class MyException(message: String) : Exception(message)

class SomeOtherException(message: String) : Exception(message)

class UsefulException(message: String) : Exception(message)

class AnotherUsefulException(message: String) : Exception(message)

Please note that all this can be defined in the same file.

Setting isAccessible to true

You seem to be always settings isAccessible to true. This is only needed if you are accessing methods outside their "access modifier", for example if you are trying to access a private method from another class.

Since you are only calling public methods (on public classes), this is not required.

Support for javax.tools is not for all android versions

You are using packages from javax.tools, this is not available on every android version, see the following SO question: NoClassDefFoundException when using javax.tools package, make sure to properly test on the oldest android version you are targetting.

To avoid these packages, manually define a class using byte arrays, and load that instead of the output of the compilation