Ttykuu

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.$nameException",
 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("$nameException", 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 NameException extends java.lang.Exception 
 public NameException(java.lang.String message) 
 super(message);
 
 public NameException(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?