* limitations under the License.
 */

package org.gradle.model.internal.asm;

import org.objectweb.asm.MethodVisitor;

public interface BytecodeFragment {

    BytecodeFragment NO_OP = visitor -> {};

    void emit(MethodVisitor visitor);

            Set<ImmutableAttributes> candidates = attributeBasedMappings.keySet();
            List<ImmutableAttributes> matches = matcher.matches(candidates, variantAttributes, AttributeMatchingExplanationBuilder.NO_OP);
            if (matches.size() == 1) {
                Collection<Action<? super VariantVersionMappingStrategy>> actions = attributeBasedMappings.get(matches.get(0));

package org.gradle.cache;

public interface CleanupProgressMonitor {

    void incrementDeleted();

    void incrementSkipped();

    void incrementSkipped(long amount);

    CleanupProgressMonitor NO_OP = new CleanupProgressMonitor() {
        @Override
        public void incrementDeleted() {
        }

        @Override
        public void incrementSkipped() {
        }

        @Override

#include "tensorflow/c/eager/immediate_execution_tensor_handle.h"
#include "tensorflow/c/experimental/ops/array_ops.h"
#include "tensorflow/c/experimental/ops/math_ops.h"
#include "tensorflow/c/experimental/ops/nn_ops.h"
#include "tensorflow/core/lib/llvm_rtti/llvm_rtti.h"
#include "tensorflow/core/platform/errors.h"

using std::vector;
using tensorflow::ops::BiasAddGrad;
using tensorflow::ops::ReluGrad;

namespace tensorflow {

import org.gradle.internal.Actions;

/**
 * A service that injects dependency substitution rules into the build.
 */
public interface DependencySubstitutionRules {
    DependencySubstitutionRules NO_OP = new DependencySubstitutionRules() {
        @Override
        public Action<DependencySubstitution> getRuleAction() {
            return Actions.doNothing();
        }

        @Override

 * @see CacheBuilder#withCleanupStrategy(CacheCleanupStrategy)
 */
public interface CleanupAction {

    void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor);

    CleanupAction NO_OP = new CleanupAction() {
        @Override
        public void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor) {
            // no-op
        }
    };

        }
        if (subscriptions.isRequested(OperationType.GENERIC)) {
            return new ClientForwardingBuildOperationListener(progressEventConsumer);
        }
        return NO_OP;
    }

    @Nonnull
    private ProblemsProgressEventConsumer createProblemsProgressConsumer(ProgressEventConsumer progressEventConsumer) {

    }

    @Override
    public <T> Property<T> property(Class<T> valueType) {
        return new DefaultProperty<>(PropertyHost.NO_OP, valueType);
    }

    @Override
    public <T> ListProperty<T> listProperty(Class<T> elementType) {
        return new DefaultListProperty<>(PropertyHost.NO_OP, elementType);
    }

    @Override
    public <T> SetProperty<T> setProperty(Class<T> elementType) {
        return broken();

import org.gradle.internal.state.ModelObject;

import javax.annotation.Nullable;

@ServiceScope({Scope.Global.class, Scope.Project.class})
public interface PropertyHost {
    PropertyHost NO_OP = producer -> null;

    /**
     * Returns null if the host allows reads of its state, or a string that explains why reads are not allowed.
     */
    @Nullable
    String beforeRead(@Nullable ModelObject producer);

                    def filePropertyFactory = new DefaultFilePropertyFactory(PropertyHost.NO_OP, fileResolver, fileCollectionFactory)
                    return new DefaultProjectLayout(fileResolver.resolve("."), fileResolver, DefaultTaskDependencyFactory.withNoAssociatedProject(), PatternSets.getNonCachingPatternSetFactory(), PropertyHost.NO_OP, fileCollectionFactory, filePropertyFactory, filePropertyFactory)
                }