* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.history.changes;

public interface ChangeContainer {
    /**
     * Propagate changes to the visitor.
     *
     * @return Whether the visitor still wants to obtain more changes.
     */
    boolean accept(ChangeVisitor visitor);

        ChangeContainer implementationChanges = new ImplementationChanges(
            previousImplementation, lastExecution.getAdditionalImplementations(),
            currentImplementation, currentAdditionalImplementations,
            executable);

        // Capture non-file input changes
        ChangeContainer inputPropertyChanges = new PropertyChanges(

 */
public class CachingChangeContainer implements ChangeContainer {
    private final ChangeContainer delegate;
    private final List<Change> cache = new ArrayList<Change>();
    private final int maxCachedChanges;
    private boolean cached;
    private boolean overrun;

    public CachingChangeContainer(int maxCachedChanges, ChangeContainer delegate) {
        this.maxCachedChanges = maxCachedChanges;

 * - Will only emit changes of a single type (from a single delegate change set)
 */
public class SummarizingChangeContainer implements ChangeContainer {
    private final List<ChangeContainer> sources;

    public SummarizingChangeContainer(ChangeContainer... sources) {
        this.sources = ImmutableList.copyOf(sources);
    }

    @Override
    public boolean accept(ChangeVisitor visitor) {

import org.gradle.api.Describable;
import org.gradle.api.GradleException;

public class ErrorHandlingChangeContainer implements ChangeContainer {
    private final Describable executable;
    private final ChangeContainer delegate;

    public ErrorHandlingChangeContainer(Describable executable, ChangeContainer delegate) {
        this.executable = executable;
        this.delegate = delegate;
    }

    @Override

 */

package org.gradle.internal.execution.history.changes


import spock.lang.Specification

class SummarizingChangeContainerTest extends Specification {

    def state1 = Mock(ChangeContainer)
    def state2 = Mock(ChangeContainer)
    def state = new SummarizingChangeContainer(state1, state2)
    def visitor = new CollectingChangeVisitor()

    def "looks for changes in all delegate change sets"() {
        when:

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.history.changes;

public class PreviousSuccessChanges implements ChangeContainer {
    private static final Change PREVIOUS_FAILURE = new DescriptiveChange("Task has failed previously.");

    private final boolean successful;

    public PreviousSuccessChanges(boolean successful) {

 * limitations under the License.
 */

package org.gradle.internal.execution.history.changes;

import org.gradle.api.InvalidUserDataException;

public interface InputFileChanges extends ChangeContainer {
    boolean accept(String propertyName, ChangeVisitor visitor);

    InputFileChanges EMPTY = new InputFileChanges() {

        @Override
        public boolean accept(ChangeVisitor visitor) {

import spock.lang.Specification

class ErrorHandlingChangeContainerTest extends Specification {
    def task = Stub(Describable) {
        getDisplayName() >> "task ':test'"
    }
    def delegate = Mock(ChangeContainer)
    def changes = new ErrorHandlingChangeContainer(task, delegate)

    def "accept error reports task path"() {
        when:
        changes.accept(Mock(ChangeVisitor))
        then:

import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Sets;
import org.gradle.api.Describable;

import java.util.stream.Stream;

public class PropertyChanges implements ChangeContainer {

    private final ImmutableSortedSet<String> previous;
    private final ImmutableSortedSet<String> current;
    private final String title;
    private final Describable executable;