}
        }
    }

    ExecutionEngine.Result outOfDate(UnitOfWork unitOfWork, String... expectedReasons) {
        return outOfDate(unitOfWork, ImmutableList.<String> copyOf(expectedReasons))
    }

    ExecutionEngine.Result outOfDate(UnitOfWork unitOfWork, List<String> expectedReasons) {
        def result = execute(unitOfWork)

        Status status = delegate.status();
        if (!status.hasChanged()) {
            gateKeeper.close();
        }
        return status;
    }

    @Override
    public void outOfDate() {
        delegate.outOfDate();
    }

    @Override
    public void upToDate(@Nullable Throwable failure) {
        delegate.upToDate(failure);
        gateKeeper.close();
    }

            }
            return delegate.status();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void outOfDate() {
        lock.lock();
        try {
            delegate.outOfDate();
            outOfDate = true;
            upToDate.signalAll();
        } finally {
            lock.unlock();
        }
    }

    @Override

        boolean outOfDate = false;
        FileLock.State previousState = fileLockStateReference.get();
        if (previousState == null) {
            outOfDate = true;
        } else if (currentCacheState.hasBeenUpdatedSince(previousState)) {
            LOG.info("Invalidating in-memory cache of {}", cacheId);
            outOfDate = true;
        }
        if (outOfDate) {

     *
     * @return True if the grammar generation is out of date (needs regen); false otherwise.
     */
    public boolean isOutOfDate() {
        return outOfDate;
    }

    /**
     * Marks the plan as out of date.
     */
    void markOutOfDate() {
        this.outOfDate = true;
    }

        }
    }

    public DeploymentInternal getDeployment() {
        return delegate;
    }

    public void outOfDate() {
        delegate.outOfDate();
    }

    public void upToDate(@Nullable Throwable failure) {
        delegate.upToDate(failure);
        restart();
    }

    public DeploymentHandle getHandle() {

 * limitations under the License.
 */

package org.gradle.deployment.internal;

import javax.annotation.Nullable;

public interface DeploymentInternal extends Deployment {
    void outOfDate();
    void upToDate(@Nullable Throwable failure);

    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr><td>outOfDate</td></tr>
            <tr><td>removed</td></tr>
        </table>
    </section>

                        handle.start(deployment.getDeployment());
                        if (pendingChanges.hasRemainingChanges()) {
                            deployment.outOfDate();
                        }
                        deployments.put(name, deployment);
                        return handle;
                    }
                });
            } else {

    public synchronized Status status() {
        Status result = new DefaultDeploymentStatus(changed, failure);
        changed = false;
        return result;
    }

    @Override
    public synchronized void outOfDate() {
        changed = true;
        failure = null;
    }

    @Override
    public synchronized void upToDate(@Nullable Throwable failure) {
        this.failure = failure;
    }