new DefaultModelBuildingRequest(request).setModelSource(source);
                        return defaultModelBuilder.readRawModel(gaBuildingRequest, problems);
                    } catch (ModelBuildingException e) {
                        // gathered with problem collector
                    }
                }
                return null;
            }

        if (!Constants.T.equals(scheduledJob.getAvailable())) {
            logger.info("Inactive Job {}:{}", id, scheduledJob.getName());
            try {
                unregister(scheduledJob);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to delete Job {}", scheduledJob, e);
                }
            }
            return;
        }

            if (StringUtils.isEmpty(nonce) || !nonce.equals(stateData.getNonce())) {
                throw new SsoLoginException("could not validate nonce");
            }
        } catch (final SsoLoginException e) {
            throw e;
        } catch (final Exception e) {
            throw new SsoLoginException("could not validate nonce", e);
        }
    }

                                -1,
                                null));
                    }
                    server.setPassword(securityDispatcher.decrypt(password));
                } catch (SecDispatcherException | IOException e) {
                    problems.add(new DefaultSettingsProblem(
                            "Failed to decrypt password for server " + server.getId() + ": " + e.getMessage(),

        if (propertyType == java.util.Date.class) {
            try {
                return TimestampConversionUtil.toDate(arg);
            } catch (final ParseRuntimeException ex) {
                try {
                    return DateConversionUtil.toDate(arg);
                } catch (final ParseRuntimeException ex2) {
                    return TimeConversionUtil.toDate(arg);
                }
            }

            }
        } catch (XMLStreamException | IOException e) {
            throw new PlexusConfigurationException(e.getMessage(), e);
        }
    }

    private static BufferedInputStream reset(StreamSupplier inputSupplier, BufferedInputStream bis) throws IOException {
        try {
            bis.reset();
            return bis;
        } catch (IOException e) {

        final String value = System.getProperty("corelib.timeout_task.num_of_threads");
        if (StringUtil.isNotBlank(value)) {
            try {
                nThreads = Integer.parseInt(value);
            } catch (final NumberFormatException e) {
                logger.warn("Failed to parse " + value, e);
            }
        }
        if (nThreads < 1) {
            nThreads = 1;
        }

     */
    public static final ResourceBundle getBundle(final String name) {
        assertArgumentNotEmpty("name", name);

        try {
            return ResourceBundle.getBundle(name);
        } catch (final MissingResourceException ignore) {
            return null;
        }
    }

    /**
     * バンドルを返します。 見つからない場合は、<code>null</code>を返します。
     *
     * @param name

        assertArgumentNotNull("os", os);
        assertArgumentNotEmpty("encoding", encoding);

        try {
            return new OutputStreamWriter(os, encoding);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * プラットフォームデフォルトエンコーディングでファイルへ出力する{@link Writer}を作成します。
     *
     * @param file

                        expressionDocumentation.putAll(doco);
                    }
                } catch (IOException e) {
                    throw new ExpressionDocumentationException(
                            "Failed to read documentation for expression root: " + root, e);
                } catch (XmlPullParserException e) {
                    throw new ExpressionDocumentationException(