*/
    public static <T> T newInstance(final Constructor<T> constructor, final Object... args)
            throws InstantiationRuntimeException, IllegalAccessRuntimeException {
        assertArgumentNotNull("constructor", constructor);

        try {
            return constructor.newInstance(args);
        } catch (final InstantiationException e) {

        super(MessageFormatter.getMessage(messageCode, args), cause);
        this.argName = argName;
        this.messageCode = messageCode;
        this.args = args;
    }

    /**
     * Returns the name of the argument.
     *
     * @return Name of the argument
     */
    public String getArgName() {
        return argName;
    }

     * @param messageCode message code
     * @param args arguments for messages
     * @param cause cause of exception
     */
    public ClRuntimeException(final String messageCode, final Object[] args, final Throwable cause) {
        super(cause);
        this.messageCode = messageCode;
        this.args = args;
        simpleMessage = MessageFormatter.getSimpleMessage(messageCode, args);
        message = "[" + messageCode + "]" + simpleMessage;

         * args = new HashMap<>(); args.put("mode", "normal"); args.put("discardPunctuation", "false"); if
         * (Strings.isNullOrEmpty(path)) { args.put("userDictionary", path); } if (Strings.isNullOrEmpty(encoding)) {
         * args.put("userDictionaryEncoding", encoding); } final JapaneseTokenizerFactory japaneseTokenizerFactory = new

     *
     * @param messageCode
     *            the message code
     * @param args
     *            the message arguments
     * @param cause
     *            the cause
     */
    public FileAccessException(final String messageCode, final Object[] args, final Throwable cause) {
        super(messageCode, args, cause);
    }

    /**

        return pcd.getRawClass();
    }

    @Override
    public <T> T invoke(final Object target, final Object... args) {
        assertArgumentNotNull("target", target);

        return MethodUtil.invoke(method, target, args);
    }

    @Override
    public <T> T invokeStatic(final Object... args) {
        if (!isStatic()) {
            throw new MethodNotStaticRuntimeException(getBeanDesc().getBeanClass(), methodName);

    /**
     * Creates a new instance.
     *
     * @param <T>
     *            The type of the Bean class
     * @param args
     *            The arguments to pass to the constructor
     * @return A new instance
     */
    <T> T newInstance(Object... args);

    /**
     * Returns the {@link ConstructorDesc} for the given parameter types.
     *
     * @param paramTypes

     * @param target
     *            The object on which the underlying method is to be called. {@literal null} for {@literal static} methods
     * @param args
     *            The arguments used for the method call
     * @return The result of dispatching the method to the object using the parameters {@code args}
     * @throws IllegalAccessRuntimeException

     */
    protected boolean bucketExists(final String name) {
        try {
            final BucketExistsArgs args = BucketExistsArgs.builder().bucket(name).build();
            return minioClient.bucketExists(args);
        } catch (final Exception e) {
            throw new CrawlingAccessException("Failed to check bucket existence: bucket=" + name, e);
        }
    }

     * @param args
     *            Arguments
     * @return Formatted message string
     */
    public static LogMessage format(final String messageCode, final Object... args) {
        assertArgumentNotEmpty("messageCode", messageCode);

        final char messageType = messageCode.charAt(0);
        final String message = MessageFormatter.getSimpleMessage(messageCode, args);
        switch (messageType) {