* in the .classpath file when the 'eclipse' task is invoked (which - btw - the Buildship plugin does not do).
     *
     * What we do here is a quick workaround to remove the duplication from the generated .classpath files. The
     * proper solution has a much larger scope: we'd need to decouple the EclipseProject TAPI model generation

    }

    @Override
    protected TaskProvider<? extends T> createExistingProvider(String name, T object) {
        // TODO: This isn't quite right. We're leaking the _implementation_ type here.  But for tasks, this is usually right.
        return Cast.uncheckedCast(getInstantiator().newInstance(ExistingTaskProvider.class, this, object.getName(), new DslObject(object).getDeclaredType()));
    }

    @Override

            implementation(constraint(project())) // is getImplementation().addConstraint(constraint(project()))
        }
    }
}


// The #module and #constraint methods here allow the usage of named arguments in Kotlin, even though the signature is overall the same as the Java method.


/**
 * Creates a dependency based on the group, name and version (GAV) coordinates.
 *
 * @since 8.0

If task B uses the output of task A, then task A must complete before task B begins.

- A task may declare its dependencies explicitly.
- A task may depend on other tasks implicitly.

Here is an example of explicit task dependency:
[.multi-language-sample]
=====
[source, kotlin]
----
tasks.register("hello") {
    doLast {
        println("Hello!")
    }
}

[[build_jenkins]]
= Executing Gradle builds on Jenkins

TIP: Top engineering teams using Jenkins have been able to reduce CI build time by up to 90% by using the Gradle Build Cache. https://gradle.org/training/#build-cache-deep-dive[Register here] for our Build Cache training session to learn how your team can achieve similar results.

Building Gradle projects doesn't stop with the developer's machine.

// limitations under the License.

[[third_party_integration]]
= Gradle & Third-party Tools

Gradle can be integrated with many different third-party tools such as IDEs and continuous integration platforms. Here we look at some of the more common ones as well as how to integrate your own tool with Gradle.

[[ides]]
== IDEs

Android Studio::

== Java and Kotlin compilation

The <<caching_java_projects.adoc#java_compilation,discussion>> above in “Caching Java projects” is equally relevant here, with the caveat that, for projects that include Kotlin source code, the Kotlin compiler does not currently support <<java_plugin.adoc#sec:java_compile_avoidance,compile avoidance>> in the way that the Java compiler does.

Develocity provides much richer data compared to what can be obtained from CI servers.
For example, you can get insights into the execution of single tasks, how many tasks were retrieved from the cache, how long it took to download from the cache, the properties that were used to calculate the cache key and more.

// more.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_

#include "gtest/internal/gtest-port.h"

// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
// libstdc++ (which is where cxxabi.h comes from).
# if GTEST_HAS_CXXABI_H_
#  include <cxxabi.h>
# elif defined(__HP_aCC)
#  include <acxx_demangle.h>

    // we need this using statement.
    using ::operator <<;
    *ss_ << value;
  }
#endif  // GTEST_OS_SYMBIAN

  // We'll hold the text streamed to this object here.
  const internal::scoped_ptr< ::std::stringstream> ss_;

  // We declare (but don't implement) this to prevent the compiler
  // from implementing the assignment operator.
  void operator=(const Message&);
};