Question

I have a series of exception messages:

enum myEnum {
    BASIC(1, "An error occurred"),
    WITH_ERRORID(2, "Error id: {0}"),
    DETAILED(3, "Problem in record {0} with index {1}");
};

I also have a single, reusable authority for logging and throwing a custom exception:

public void throwException (myEnum message) {
    log.addEntry(message);
    throw new CustomException(message);
}

Calling the method is straight forward:

throwException (myEnum.DETAILED);

I am now wrestling with the most elegant way to format the strings. I could add a toString() method to the enum to format the string based on the number of inputs, and change throwException to accept a String instead:

String msg = message.toString(variable);
throwException (msg);

String msg2 = message.toString(variable, otherVariable);
throwException (msg2);

String msg3 = message.toString(variable, otherVariable, nextVariable);
throwException (msg3);

While this would work, I would like to move the the repeated toString calls to within throwException(). I was considering passing an ArrayList to throwException(). But I would then have to check the size of the list before I format the string:

if (list.size == 1) MessageFormat.format(message, list.get(0));
if (list.size == 2) MessageFormat.format(message, list.get(0), list.get(1));

Is a better technical or design approach for solving this problem?

Answer 1

Since you’re using the enum type declaration, I’m going to assume you’re using JSE 5 or later.

Given that, I’d say you’re most of the way to a solution. Here’s my version of your enum:

public enum myEnum {
    BASIC(1, "An error occurred"),
    WITH_ERRORID(2, "Error id: {0}"),
    DETAILED(3, "Problem in record {0} with index {1}");
    private int key = 0;
    private String format = null;

    private myEnum(int aKey, String aFormat) {
        this.key=aKey;
        this.format=aFormat;
    }

    /**
     * This will take whatever input you provide and use the enum instance format
     * string to generate a message.
     */
    public String getMessage(Object... someContents) {
        return MessageFormat.format(this.format, someContents);
    }
}

To use these modifications, you need to make one minor change to your throwException() implementation:

public void throwException (myEnum message, String... errorContents) {
    String formattedMessage = message.getMessage(errorContents);
    log.addEntry(formattedMessage);
    throw new CustomException(formattedMessage);
}

Using the varargs notation means that you can pass zero or more values of the same type, and they’re treated as an array in the called code. No arguments? It’s treated as a zero-length array, and no formatting occurs.

The only difficulty remaining is that I can’t see any obvious way to alert the developer at compile-time that more arguments are required to fill out the formatting. If you pass no error details with a myEnum.DETAILED, you get back the format you started with.

You should already have the strings needed to inject into your formats; now you just need to pass them to the throwException() method. How does this look as an option?