* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.tasks;

/**
 * Provides information about some work which was performed.
 */
public interface WorkResult {
    boolean getDidWork();

    /**
     * Returns this result if it did work, otherwise returns the result given as a parameter.
     *
     * @since 6.0
     */

        NativeLanguage sourceLanguage = NativeLanguage.CPP;
        NativeToolChainInternal toolChain = getToolChain(sourceLanguage, targetNativePlatform);

        // TODO - don't select again here, as the selection is already performed to select the toolchain
        PlatformToolProvider toolProvider = toolChain.select(sourceLanguage, targetNativePlatform);

  // stream_. If true, computation is performed by stream_ and transfers are
  // performed by host_to_device/device_to_device stream or borrowing a stream
  // for each device to host transfer.
  const bool use_multiple_streams_;
  // If use_multiple_streams_, host to device transfers are performed using this
  // stream.
  std::shared_ptr<se::Stream> host_to_device_stream_ TF_GUARDED_BY(mu_);

// system call to minimize copies.
//
// if handled == true, sendFile returns the number (potentially zero) of bytes
// copied and any non-EOF error.
//
// if handled == false, sendFile performed no work.
func sendFile(c *netFD, r io.Reader) (written int64, err error, handled bool) {
	var remain int64 = 1<<63 - 1 // by default, copy until EOF

	lr, ok := r.(*io.LimitedReader)
	if ok {
		remain, r = lr.N, lr.R

// system call to minimize copies.
//
// if handled == true, sendFile returns the number of bytes copied and any
// non-EOF error.
//
// if handled == false, sendFile performed no work.
func sendFile(fd *netFD, r io.Reader) (written int64, err error, handled bool) {
	var n int64 = 0 // by default, copy until EOF.

	lr, ok := r.(*io.LimitedReader)
	if ok {
		n, r = lr.N, lr.R
		if n <= 0 {

                d.outgoing.artifact(jar)
            }
        '''
        repoC.commit('initial version')
    }

    @ToBeFixedForConfigurationCache
    def "git version lookup and checkout is performed once per version selector per build invocation"() {
        repoA.file("build.gradle") << """
            dependencies {
                compile 'test:testB:1.2'
                compile 'test:testC:1.2'
            }

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

package org.gradle.cache;

/**
 * Specifies the details of cache cleanup, including the action to be performed and the frequency at which cache cleanup should occur.
 */
public interface CacheCleanupStrategy {
    CacheCleanupStrategy NO_CLEANUP = new CacheCleanupStrategy() {
        @Override

import org.gradle.tooling.events.OperationDescriptor;

import javax.annotation.Nullable;

/**
 * Implementation of the {@link OperationDescriptor} interface, for those operations which are performed by the consumer.
 */
public class ConsumerOperationDescriptor implements OperationDescriptor {
    private final String displayName;

    public ConsumerOperationDescriptor(String displayName) {

 * limitations under the License.
 */

package org.gradle.test.fixtures.concurrent

import java.util.concurrent.atomic.AtomicReference

/**
 * Represents some operation performed by a test. Has a start and end instant.
 */
class NamedOperation {
    final String name
    final Instant start
    private final AtomicReference<Instant> end = new AtomicReference<>()

     * graph to be traversed
     * @param moduleAction an action to be performed on each node (module) in the graph
     * @param dependencyAction an action to be performed on each edge (dependency) in the graph
     * @param visited tracks the visited nodes during the recursive traversal
     */
    public static void eachElement(