    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.math;
    018
    019    import java.io.EOFException;
    020    import java.io.IOException;
    021    import java.io.PrintStream;
    022    import java.io.PrintWriter;
    023    import java.text.MessageFormat;
    024    import java.text.ParseException;
    025    import java.util.ConcurrentModificationException;
    026    import java.util.Locale;
    027    import java.util.NoSuchElementException;
    028
    029    import org.apache.commons.math.exception.MathThrowable;
    030    import org.apache.commons.math.exception.util.DummyLocalizable;
    031    import org.apache.commons.math.exception.util.Localizable;
    032    import org.apache.commons.math.exception.util.LocalizedFormats;
    033
    034    /**
    035    * Base class for commons-math unchecked exceptions.
    036    *
    037    * @version $Revision: 1070725 $ $Date: 2011-02-15 02:31:12 +0100 (mar. 15 f??vr. 2011) $
    038    * @since 2.0
    039    */
    040    public class MathRuntimeException extends RuntimeException implements MathThrowable {
    041
    042        /** Serializable version identifier. */
    043        private static final long serialVersionUID = 9058794795027570002L;
    044
    045        /**
    046         * Pattern used to build the message.
    047         */
    048        private final Localizable pattern;
    049
    050        /**
    051         * Arguments used to build the message.
    052         */
    053        private final Object[] arguments;
    054
    055        /**
    056         * Constructs a new <code>MathRuntimeException</code> with specified
    057         * formatted detail message.
    058         * Message formatting is delegated to {@link java.text.MessageFormat}.
    059         * @param pattern format specifier
    060         * @param arguments format arguments
    061         * @deprecated as of 2.2 replaced by {@link #MathRuntimeException(Localizable, Object...)}
    062         */
    063        @Deprecated
    064        public MathRuntimeException(final String pattern, final Object ... arguments) {
    065            this(new DummyLocalizable(pattern), arguments);
    066        }
    067
    068        /**
    069         * Constructs a new <code>MathRuntimeException</code> with specified
    070         * formatted detail message.
    071         * Message formatting is delegated to {@link java.text.MessageFormat}.
    072         * @param pattern format specifier
    073         * @param arguments format arguments
    074         * @since 2.2
    075         */
    076        public MathRuntimeException(final Localizable pattern, final Object ... arguments) {
    077            this.pattern   = pattern;
    078            this.arguments = (arguments == null) ? new Object[0] : arguments.clone();
    079        }
    080
    081        /**
    082         * Constructs a new <code>MathRuntimeException</code> with specified
    083         * nested <code>Throwable</code> root cause.
    084         *
    085         * @param rootCause  the exception or error that caused this exception
    086         *                   to be thrown.
    087         */
    088        public MathRuntimeException(final Throwable rootCause) {
    089            super(rootCause);
    090            this.pattern   = LocalizedFormats.SIMPLE_MESSAGE;
    091            this.arguments = new Object[] { (rootCause == null) ? "" : rootCause.getMessage() };
    092        }
    093
    094        /**
    095         * Constructs a new <code>MathRuntimeException</code> with specified
    096         * formatted detail message and nested <code>Throwable</code> root cause.
    097         * Message formatting is delegated to {@link java.text.MessageFormat}.
    098         * @param rootCause the exception or error that caused this exception
    099         * to be thrown.
    100         * @param pattern format specifier
    101         * @param arguments format arguments
    102         * @deprecated as of 2.2 replaced by {@link #MathRuntimeException(Throwable, Localizable, Object...)}
    103         */
    104        @Deprecated
    105        public MathRuntimeException(final Throwable rootCause,
    106                                    final String pattern, final Object ... arguments) {
    107            this(rootCause, new DummyLocalizable(pattern), arguments);
    108        }
    109
    110        /**
    111         * Constructs a new <code>MathRuntimeException</code> with specified
    112         * formatted detail message and nested <code>Throwable</code> root cause.
    113         * Message formatting is delegated to {@link java.text.MessageFormat}.
    114         * @param rootCause the exception or error that caused this exception
    115         * to be thrown.
    116         * @param pattern format specifier
    117         * @param arguments format arguments
    118         * @since 2.2
    119         */
    120        public MathRuntimeException(final Throwable rootCause,
    121                                    final Localizable pattern, final Object ... arguments) {
    122            super(rootCause);
    123            this.pattern   = pattern;
    124            this.arguments = (arguments == null) ? new Object[0] : arguments.clone();
    125        }
    126
    127        /**
    128         * Builds a message string by from a pattern and its arguments.
    129         * @param locale Locale in which the message should be translated
    130         * @param pattern format specifier
    131         * @param arguments format arguments
    132         * @return a message string
    133         * @since 2.2
    134         */
    135        private static String buildMessage(final Locale locale, final Localizable pattern,
    136                                           final Object ... arguments) {
    137            return new MessageFormat(pattern.getLocalizedString(locale), locale).format(arguments);
    138        }
    139
    140        /** Gets the pattern used to build the message of this throwable.
    141        *
    142        * @return the pattern used to build the message of this throwable
    143        * @deprecated as of 2.2 replaced by {@link #getSpecificPattern()} and {@link #getGeneralPattern()}
    144        */
    145        @Deprecated
    146        public String getPattern() {
    147            return pattern.getSourceString();
    148        }
    149
    150        /**
    151         * {@inheritDoc}
    152         *
    153         * @since 2.2
    154         */
    155        public Localizable getSpecificPattern() {
    156            return null;
    157        }
    158
    159        /**
    160         * {@inheritDoc}
    161         *
    162         * @since 2.2
    163         */
    164        public Localizable getGeneralPattern() {
    165            return pattern;
    166        }
    167
    168        /** {@inheritDoc} */
    169        public Object[] getArguments() {
    170            return arguments.clone();
    171        }
    172
    173        /** Gets the message in a specified locale.
    174         *
    175         * @param locale Locale in which the message should be translated
    176         *
    177         * @return localized message
    178         */
    179        public String getMessage(final Locale locale) {
    180            if (pattern != null) {
    181                return buildMessage(locale, pattern, arguments);
    182            }
    183            return "";
    184        }
    185
    186        /** {@inheritDoc} */
    187        @Override
    188        public String getMessage() {
    189            return getMessage(Locale.US);
    190        }
    191
    192        /** {@inheritDoc} */
    193        @Override
    194        public String getLocalizedMessage() {
    195            return getMessage(Locale.getDefault());
    196        }
    197
    198        /**
    199         * Prints the stack trace of this exception to the standard error stream.
    200         */
    201        @Override
    202        public void printStackTrace() {
    203            printStackTrace(System.err);
    204        }
    205
    206        /**
    207         * Prints the stack trace of this exception to the specified stream.
    208         *
    209         * @param out  the <code>PrintStream</code> to use for output
    210         */
    211        @Override
    212        public void printStackTrace(final PrintStream out) {
    213            synchronized (out) {
    214                PrintWriter pw = new PrintWriter(out, false);
    215                printStackTrace(pw);
    216                // Flush the PrintWriter before it's GC'ed.
    217                pw.flush();
    218            }
    219        }
    220
    221        /**
    222         * Constructs a new <code>ArithmeticException</code> with specified formatted detail message.
    223         * Message formatting is delegated to {@link java.text.MessageFormat}.
    224         * @param pattern format specifier
    225         * @param arguments format arguments
    226         * @return built exception
    227         * @deprecated as of 2.2 replaced by {@link #createArithmeticException(Localizable, Object...)}
    228         */
    229        @Deprecated
    230        public static ArithmeticException createArithmeticException(final String pattern,
    231                                                                    final Object ... arguments) {
    232            return createArithmeticException(new DummyLocalizable(pattern), arguments);
    233        }
    234
    235        /**
    236         * Constructs a new <code>ArithmeticException</code> with specified formatted detail message.
    237         * Message formatting is delegated to {@link java.text.MessageFormat}.
    238         * @param pattern format specifier
    239         * @param arguments format arguments
    240         * @return built exception
    241         * @since 2.2
    242         */
    243        public static ArithmeticException createArithmeticException(final Localizable pattern,
    244                                                                    final Object ... arguments) {
    245            return new ArithmeticException() {
    246
    247                /** Serializable version identifier. */
    248                private static final long serialVersionUID = 5305498554076846637L;
    249
    250                /** {@inheritDoc} */
    251                @Override
    252                public String getMessage() {
    253                    return buildMessage(Locale.US, pattern, arguments);
    254                }
    255
    256                /** {@inheritDoc} */
    257                @Override
    258                public String getLocalizedMessage() {
    259                    return buildMessage(Locale.getDefault(), pattern, arguments);
    260                }
    261
    262            };
    263        }
    264
    265        /**
    266         * Constructs a new <code>ArrayIndexOutOfBoundsException</code> with specified formatted detail message.
    267         * Message formatting is delegated to {@link java.text.MessageFormat}.
    268         * @param pattern format specifier
    269         * @param arguments format arguments
    270         * @return built exception
    271         * @deprecated as of 2.2 replaced by {@link #createArrayIndexOutOfBoundsException(Localizable, Object...)}
    272         */
    273        @Deprecated
    274        public static ArrayIndexOutOfBoundsException createArrayIndexOutOfBoundsException(final String pattern,
    275                                                                                          final Object ... arguments) {
    276            return createArrayIndexOutOfBoundsException(new DummyLocalizable(pattern), arguments);
    277        }
    278
    279        /**
    280         * Constructs a new <code>ArrayIndexOutOfBoundsException</code> with specified formatted detail message.
    281         * Message formatting is delegated to {@link java.text.MessageFormat}.
    282         * @param pattern format specifier
    283         * @param arguments format arguments
    284         * @return built exception
    285         * @since 2.2
    286         */
    287        public static ArrayIndexOutOfBoundsException createArrayIndexOutOfBoundsException(final Localizable pattern,
    288                                                                                          final Object ... arguments) {
    289            return new ArrayIndexOutOfBoundsException() {
    290
    291                /** Serializable version identifier. */
    292                private static final long serialVersionUID = 6718518191249632175L;
    293
    294                /** {@inheritDoc} */
    295                @Override
    296                public String getMessage() {
    297                    return buildMessage(Locale.US, pattern, arguments);
    298                }
    299
    300                /** {@inheritDoc} */
    301                @Override
    302                public String getLocalizedMessage() {
    303                    return buildMessage(Locale.getDefault(), pattern, arguments);
    304                }
    305
    306            };
    307        }
    308
    309        /**
    310         * Constructs a new <code>EOFException</code> with specified formatted detail message.
    311         * Message formatting is delegated to {@link java.text.MessageFormat}.
    312         * @param pattern format specifier
    313         * @param arguments format arguments
    314         * @return built exception
    315         * @deprecated as of 2.2 replaced by {@link #createEOFException(Localizable, Object...)}
    316         */
    317        @Deprecated
    318        public static EOFException createEOFException(final String pattern,
    319                                                      final Object ... arguments) {
    320            return createEOFException(new DummyLocalizable(pattern), arguments);
    321        }
    322
    323        /**
    324         * Constructs a new <code>EOFException</code> with specified formatted detail message.
    325         * Message formatting is delegated to {@link java.text.MessageFormat}.
    326         * @param pattern format specifier
    327         * @param arguments format arguments
    328         * @return built exception
    329         * @since 2.2
    330         */
    331        public static EOFException createEOFException(final Localizable pattern,
    332                                                      final Object ... arguments) {
    333            return new EOFException() {
    334
    335                /** Serializable version identifier. */
    336                private static final long serialVersionUID = 6067985859347601503L;
    337
    338                /** {@inheritDoc} */
    339                @Override
    340                public String getMessage() {
    341                    return buildMessage(Locale.US, pattern, arguments);
    342                }
    343
    344                /** {@inheritDoc} */
    345                @Override
    346                public String getLocalizedMessage() {
    347                    return buildMessage(Locale.getDefault(), pattern, arguments);
    348                }
    349
    350            };
    351        }
    352
    353        /**
    354         * Constructs a new <code>IOException</code> with specified nested
    355         * <code>Throwable</code> root cause.
    356         * <p>This factory method allows chaining of other exceptions within an
    357         * <code>IOException</code> even for Java 5. The constructor for
    358         * <code>IOException</code> with a cause parameter was introduced only
    359         * with Java 6.</p>
    360         * @param rootCause the exception or error that caused this exception
    361         * to be thrown.
    362         * @return built exception
    363         */
    364        public static IOException createIOException(final Throwable rootCause) {
    365            IOException ioe = new IOException(rootCause.getLocalizedMessage());
    366            ioe.initCause(rootCause);
    367            return ioe;
    368        }
    369
    370        /**
    371         * Constructs a new <code>IllegalArgumentException</code> with specified formatted detail message.
    372         * Message formatting is delegated to {@link java.text.MessageFormat}.
    373         * @param pattern format specifier
    374         * @param arguments format arguments
    375         * @return built exception
    376         * @deprecated as of 2.2 replaced by {@link #createIllegalArgumentException(Localizable, Object...)}
    377         */
    378        @Deprecated
    379        public static IllegalArgumentException createIllegalArgumentException(final String pattern,
    380                                                                              final Object ... arguments) {
    381            return createIllegalArgumentException(new DummyLocalizable(pattern), arguments);
    382        }
    383
    384        /**
    385         * Constructs a new <code>IllegalArgumentException</code> with specified formatted detail message.
    386         * Message formatting is delegated to {@link java.text.MessageFormat}.
    387         * @param pattern format specifier
    388         * @param arguments format arguments
    389         * @return built exception
    390         * @since 2.2
    391         */
    392        public static IllegalArgumentException createIllegalArgumentException(final Localizable pattern,
    393                                                                              final Object ... arguments) {
    394            return new IllegalArgumentException() {
    395
    396                /** Serializable version identifier. */
    397                private static final long serialVersionUID = -4284649691002411505L;
    398
    399                /** {@inheritDoc} */
    400                @Override
    401                public String getMessage() {
    402                    return buildMessage(Locale.US, pattern, arguments);
    403                }
    404
    405                /** {@inheritDoc} */
    406                @Override
    407                public String getLocalizedMessage() {
    408                    return buildMessage(Locale.getDefault(), pattern, arguments);
    409                }
    410
    411            };
    412        }
    413
    414        /**
    415         * Constructs a new <code>IllegalArgumentException</code> with specified nested
    416         * <code>Throwable</code> root cause.
    417         * @param rootCause the exception or error that caused this exception
    418         * to be thrown.
    419         * @return built exception
    420         */
    421        public static IllegalArgumentException createIllegalArgumentException(final Throwable rootCause) {
    422            IllegalArgumentException iae = new IllegalArgumentException(rootCause.getLocalizedMessage());
    423            iae.initCause(rootCause);
    424            return iae;
    425        }
    426
    427        /**
    428         * Constructs a new <code>IllegalStateException</code> with specified formatted detail message.
    429         * Message formatting is delegated to {@link java.text.MessageFormat}.
    430         * @param pattern format specifier
    431         * @param arguments format arguments
    432         * @return built exception
    433         * @deprecated as of 2.2 replaced by {@link #createIllegalStateException(Localizable, Object...)}
    434         */
    435        @Deprecated
    436        public static IllegalStateException createIllegalStateException(final String pattern,
    437                                                                        final Object ... arguments) {
    438            return createIllegalStateException(new DummyLocalizable(pattern), arguments);
    439        }
    440
    441        /**
    442         * Constructs a new <code>IllegalStateException</code> with specified formatted detail message.
    443         * Message formatting is delegated to {@link java.text.MessageFormat}.
    444         * @param pattern format specifier
    445         * @param arguments format arguments
    446         * @return built exception
    447         * @since 2.2
    448         */
    449        public static IllegalStateException createIllegalStateException(final Localizable pattern,
    450                                                                        final Object ... arguments) {
    451            return new IllegalStateException() {
    452
    453                /** Serializable version identifier. */
    454                private static final long serialVersionUID = 6880901520234515725L;
    455
    456                /** {@inheritDoc} */
    457                @Override
    458                public String getMessage() {
    459                    return buildMessage(Locale.US, pattern, arguments);
    460                }
    461
    462                /** {@inheritDoc} */
    463                @Override
    464                public String getLocalizedMessage() {
    465                    return buildMessage(Locale.getDefault(), pattern, arguments);
    466                }
    467
    468            };
    469        }
    470
    471        /**
    472         * Constructs a new <code>ConcurrentModificationException</code> with specified formatted detail message.
    473         * Message formatting is delegated to {@link java.text.MessageFormat}.
    474         * @param pattern format specifier
    475         * @param arguments format arguments
    476         * @return built exception
    477         * @deprecated as of 2.2 replaced by {@link #createConcurrentModificationException(Localizable, Object...)}
    478         */
    479        @Deprecated
    480        public static ConcurrentModificationException createConcurrentModificationException(final String pattern,
    481                                                                                            final Object ... arguments) {
    482            return createConcurrentModificationException(new DummyLocalizable(pattern), arguments);
    483        }
    484
    485        /**
    486         * Constructs a new <code>ConcurrentModificationException</code> with specified formatted detail message.
    487         * Message formatting is delegated to {@link java.text.MessageFormat}.
    488         * @param pattern format specifier
    489         * @param arguments format arguments
    490         * @return built exception
    491         * @since 2.2
    492         */
    493        public static ConcurrentModificationException createConcurrentModificationException(final Localizable pattern,
    494                                                                                            final Object ... arguments) {
    495            return new ConcurrentModificationException() {
    496
    497                /** Serializable version identifier. */
    498                private static final long serialVersionUID = -1878427236170442052L;
    499
    500                /** {@inheritDoc} */
    501                @Override
    502                public String getMessage() {
    503                    return buildMessage(Locale.US, pattern, arguments);
    504                }
    505
    506                /** {@inheritDoc} */
    507                @Override
    508                public String getLocalizedMessage() {
    509                    return buildMessage(Locale.getDefault(), pattern, arguments);
    510                }
    511
    512            };
    513        }
    514
    515        /**
    516         * Constructs a new <code>NoSuchElementException</code> with specified formatted detail message.
    517         * Message formatting is delegated to {@link java.text.MessageFormat}.
    518         * @param pattern format specifier
    519         * @param arguments format arguments
    520         * @return built exception
    521         * @deprecated as of 2.2 replaced by {@link #createNoSuchElementException(Localizable, Object...)}
    522         */
    523        @Deprecated
    524        public static NoSuchElementException createNoSuchElementException(final String pattern,
    525                                                                          final Object ... arguments) {
    526            return createNoSuchElementException(new DummyLocalizable(pattern), arguments);
    527        }
    528
    529        /**
    530         * Constructs a new <code>NoSuchElementException</code> with specified formatted detail message.
    531         * Message formatting is delegated to {@link java.text.MessageFormat}.
    532         * @param pattern format specifier
    533         * @param arguments format arguments
    534         * @return built exception
    535         * @since 2.2
    536         */
    537        public static NoSuchElementException createNoSuchElementException(final Localizable pattern,
    538                                                                          final Object ... arguments) {
    539            return new NoSuchElementException() {
    540
    541                /** Serializable version identifier. */
    542                private static final long serialVersionUID = 1632410088350355086L;
    543
    544                /** {@inheritDoc} */
    545                @Override
    546                public String getMessage() {
    547                    return buildMessage(Locale.US, pattern, arguments);
    548                }
    549
    550                /** {@inheritDoc} */
    551                @Override
    552                public String getLocalizedMessage() {
    553                    return buildMessage(Locale.getDefault(), pattern, arguments);
    554                }
    555
    556            };
    557        }
    558
    559        /**
    560         * Constructs a new <code>UnsupportedOperationException</code> with specified formatted detail message.
    561         * Message formatting is delegated to {@link java.text.MessageFormat}.
    562         * @param pattern format specifier
    563         * @param arguments format arguments
    564         * @return built exception
    565         * @since 2.2
    566         * @deprecated in 2.2. Please use {@link org.apache.commons.math.exception.MathUnsupportedOperationException}
    567         * instead.
    568         */
    569        @Deprecated
    570        public static UnsupportedOperationException createUnsupportedOperationException(final Localizable pattern,
    571                                                                                        final Object ... arguments) {
    572            return new UnsupportedOperationException() {
    573
    574                /** Serializable version identifier. */
    575                private static final long serialVersionUID = -4284649691002411505L;
    576
    577                /** {@inheritDoc} */
    578                @Override
    579                public String getMessage() {
    580                    return buildMessage(Locale.US, pattern, arguments);
    581                }
    582
    583                /** {@inheritDoc} */
    584                @Override
    585                public String getLocalizedMessage() {
    586                    return buildMessage(Locale.getDefault(), pattern, arguments);
    587                }
    588
    589            };
    590        }
    591
    592        /**
    593         * Constructs a new <code>NullPointerException</code> with specified formatted detail message.
    594         * Message formatting is delegated to {@link java.text.MessageFormat}.
    595         * @param pattern format specifier
    596         * @param arguments format arguments
    597         * @return built exception
    598         * @deprecated as of 2.2 replaced by {@link #createNullPointerException(Localizable, Object...)}
    599         */
    600        @Deprecated
    601        public static NullPointerException createNullPointerException(final String pattern,
    602                                                                      final Object ... arguments) {
    603            return createNullPointerException(new DummyLocalizable(pattern), arguments);
    604        }
    605
    606        /**
    607         * Constructs a new <code>NullPointerException</code> with specified formatted detail message.
    608         * Message formatting is delegated to {@link java.text.MessageFormat}.
    609         * @param pattern format specifier
    610         * @param arguments format arguments
    611         * @return built exception
    612         * @since 2.2
    613         * @deprecated in 2.2. Checks for "null" must not be performed in Commons-Math.
    614         */
    615        @Deprecated
    616        public static NullPointerException createNullPointerException(final Localizable pattern,
    617                                                                      final Object ... arguments) {
    618            return new NullPointerException() {
    619
    620                /** Serializable version identifier. */
    621                private static final long serialVersionUID = 451965530686593945L;
    622
    623                /** {@inheritDoc} */
    624                @Override
    625                public String getMessage() {
    626                    return buildMessage(Locale.US, pattern, arguments);
    627                }
    628
    629                /** {@inheritDoc} */
    630                @Override
    631                public String getLocalizedMessage() {
    632                    return buildMessage(Locale.getDefault(), pattern, arguments);
    633                }
    634
    635            };
    636        }
    637
    638       /**
    639         * Constructs a new <code>ParseException</code> with specified
    640         * formatted detail message.
    641         * Message formatting is delegated to {@link java.text.MessageFormat}.
    642         * @param offset offset at which error occurred
    643         * @param pattern format specifier
    644         * @param arguments format arguments
    645         * @return built exception
    646         * @deprecated as of 2.2 replaced by {@link #createParseException(int, Localizable, Object...)}
    647         */
    648        @Deprecated
    649        public static ParseException createParseException(final int offset,
    650                                                          final String pattern,
    651                                                          final Object ... arguments) {
    652            return createParseException(offset, new DummyLocalizable(pattern), arguments);
    653        }
    654
    655        /**
    656         * Constructs a new <code>ParseException</code> with specified
    657         * formatted detail message.
    658         * Message formatting is delegated to {@link java.text.MessageFormat}.
    659         * @param offset offset at which error occurred
    660         * @param pattern format specifier
    661         * @param arguments format arguments
    662         * @return built exception
    663         * @since 2.2
    664         */
    665        public static ParseException createParseException(final int offset,
    666                                                          final Localizable pattern,
    667                                                          final Object ... arguments) {
    668            return new ParseException(null, offset) {
    669
    670                /** Serializable version identifier. */
    671                private static final long serialVersionUID = 8153587599409010120L;
    672
    673                /** {@inheritDoc} */
    674                @Override
    675                public String getMessage() {
    676                    return buildMessage(Locale.US, pattern, arguments);
    677                }
    678
    679                /** {@inheritDoc} */
    680                @Override
    681                public String getLocalizedMessage() {
    682                    return buildMessage(Locale.getDefault(), pattern, arguments);
    683                }
    684
    685            };
    686        }
    687
    688        /** Create an {@link java.lang.RuntimeException} for an internal error.
    689         * @param cause underlying cause
    690         * @return an {@link java.lang.RuntimeException} for an internal error
    691         */
    692        public static RuntimeException createInternalError(final Throwable cause) {
    693
    694            final String argument = "https://issues.apache.org/jira/browse/MATH";
    695
    696            return new RuntimeException(cause) {
    697
    698                /** Serializable version identifier. */
    699                private static final long serialVersionUID = -201865440834027016L;
    700
    701                /** {@inheritDoc} */
    702                @Override
    703                public String getMessage() {
    704                    return buildMessage(Locale.US, LocalizedFormats.INTERNAL_ERROR, argument);
    705                }
    706
    707                /** {@inheritDoc} */
    708                @Override
    709                public String getLocalizedMessage() {
    710                    return buildMessage(Locale.getDefault(), LocalizedFormats.INTERNAL_ERROR, argument);
    711                }
    712
    713            };
    714
    715        }
    716
    717    }