Java UncheckedException.throwAsUncheckedException方法代码示例

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
public Application(LifecycleListener lifecycleListener) {
    this.lifecycleListener = lifecycleListener;

    try {   //try and make it look like a native app
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    } catch (Exception e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }

    this.doesSupportEditingFiles = determineIfSupportsEditingFiles();

    //read in the settings
    rootSettingsNode = DOM4JSerializer.readSettingsFile(new SettingsImportInteraction(), createFileFilter());
    if (rootSettingsNode == null) {
        rootSettingsNode = DOM4JSerializer.createBlankSettings();
    }

    singlePaneUIInstance = new SinglePaneUIInstance();
    singlePaneUIInstance.initialize(rootSettingsNode, this);

    setupUI();

    restoreSettings();

    frame.setVisible(true);
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
public void stop() {
    Throwable failure = null;
    try {
        for (Stoppable element : elements) {
            try {
                element.stop();
            } catch (Throwable throwable) {
                if (failure == null) {
                    failure = throwable;
                } else {
                    LOGGER.error(String.format("Could not stop %s.", element), throwable);
                }
            }
        }
    } finally {
        elements.clear();
    }

    if (failure != null) {
        throw UncheckedException.throwAsUncheckedException(failure);
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
public void stop() {
    lifecycleLock.lock();
    try {
        if (!stopped) {
            try {
                disconnectableInput.close();
            } catch (IOException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }

            forwardingExecuter.stop();
            stopped = true;
        }
    } finally {
        lifecycleLock.unlock();
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
private void onStartCommand(String commandDisplayName) {
    lock.lock();
    try {
        switch (state) {
            case Broken:
                throw new DaemonUnavailableException("This daemon is in a broken state and will stop.");
            case StopRequested:
                throw new DaemonUnavailableException("This daemon is currently stopping.");
            case Stopped:
                throw new DaemonUnavailableException("This daemon has stopped.");
            case Busy:
            case Canceled:
                throw new DaemonUnavailableException(String.format("This daemon is currently executing: %s", currentCommandExecution));
        }

        LOGGER.error("Command execution: started {} after {} minutes of idle", commandDisplayName, getIdleMinutes());
        try {
            setState(State.Busy);
            onStartCommand.run();
            currentCommandExecution = commandDisplayName;
            result = null;
            updateActivityTimestamp();
            updateCancellationToken();
            condition.signalAll();
        } catch (Throwable throwable) {
            setState(State.Broken);
            throw UncheckedException.throwAsUncheckedException(throwable);
        }
    } finally {
        lock.unlock();
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
@Override
public Object transform(Object o) {
    try {
        return doResolveObject(o);
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
private void waitForCommandCompletion() {
    lock.lock();
    try {
        while ((state == State.Busy || state == State.Canceled || state == State.StopRequested) && result == null) {
            try {
                condition.await();
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
        LOGGER.debug("Command execution: finished waiting for {}. Result {} with state {}", currentCommandExecution, result, state);
        if (result instanceof Throwable) {
            throw UncheckedException.throwAsUncheckedException((Throwable) result);
        }
        if (result != null) {
            return;
        }
        switch (state) {
            case Stopped:
                throw new DaemonStoppedException(stopReason);
            case Broken:
                throw new DaemonUnavailableException("This daemon is broken and will stop.");
            default:
                throw new IllegalStateException("Daemon is in unexpected state: " + state);
        }
    } finally {
        lock.unlock();
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
@Override
public String getMessage() {
    if (getMessageException != null) {
        throw UncheckedException.throwAsUncheckedException(getMessageException);
    }
    return super.getMessage();
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
@Override
public Object transform(Object obj) {
    try {
        return doReplaceObject(obj);
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
private Object getInstance(Field scalaObject) {
    try {
        return scalaObject.get(null);
    } catch (IllegalAccessException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
@Nullable
protected MetaProperty lookupProperty(MetaClass metaClass, String name) {
    if (metaClass instanceof MetaClassImpl) {
        // MetaClass.getMetaProperty(name) is very expensive when the property is not known. Instead, reach into the meta class to call a much more efficient lookup method
        try {
            return (MetaProperty) META_PROP_METHOD.invoke(metaClass, name, false);
        } catch (Throwable e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    // Some other meta-class implementation - fall back to the public API
    return metaClass.getMetaProperty(name);
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
public Object take(long timeoutValue, TimeUnit timeoutUnits) {
    Object result;
    try {
        result = queue.poll(timeoutValue, timeoutUnits);
    } catch (InterruptedException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
    if (result instanceof Throwable) {
        Throwable failure = (Throwable) result;
        throw UncheckedException.throwAsUncheckedException(failure);
    }
    return result == END ? null : result;
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
private void rethrowFailures() {
    if (tasksCancelled) {
        failures.add(new BuildCancelledException());
    }
    if (failures.isEmpty()) {
        return;
    }

    if (failures.size() > 1) {
        throw new MultipleBuildFailures(failures);
    }

    throw UncheckedException.throwAsUncheckedException(failures.get(0));
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
private void initExecutions() {
    if (!executionsInitialized) {
        try {
            Runner descriptionProvider = createRunnerFor(Arrays.asList(target), Collections.<Filter>emptyList());
            templateDescription = descriptionProvider.getDescription();
        } catch (InitializationError initializationError) {
            throw UncheckedException.throwAsUncheckedException(initializationError);
        }
        createExecutions();
        for (Execution execution : executions) {
            execution.init(target, templateDescription);
        }
        executionsInitialized = true;
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
private MessageDigestStream() {
    try {
        messageDigest = MessageDigest.getInstance("MD5");
    } catch (NoSuchAlgorithmException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入方法依赖的package包/类
private void writeXmlDeclaration(Writer writer, String encoding) {
    try {
        writer.write("<?xml version=\"1.0\"");
        if (encoding != null) {
            writer.write(" encoding=\"");
            writer.write(encoding);
            writer.write("\"");
        }
        writer.write("?>");
        writer.write(SystemProperties.getInstance().getLineSeparator());
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}