TypeUrl:      w.TypeUrl,
		// TODO: send different version for incremental eds
		VersionInfo: req.Push.PushVersion,
		Nonce:       nonce(req.Push.LedgerVersion),
		Resources:   xds.ResourcesToAny(res),
	}

	configSize := ResourceSize(res)
	configSizeBytes.With(typeTag.Value(w.TypeUrl)).Record(float64(configSize))

	ptype := "PUSH"
	if logdata.Incremental {
		ptype = "PUSH INC"
	}

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

package org.gradle.language.nativeplatform.internal.incremental;

import org.gradle.cache.FileLockManager;
import org.gradle.cache.IndexedCache;
import org.gradle.cache.IndexedCacheParameters;
import org.gradle.cache.ObjectHolder;
import org.gradle.cache.PersistentCache;

<<performance.adoc#performance_gradle,Optimizing Builds>> :: Use caches to optimize your build and understand the Gradle daemon, incremental builds and file system watching.
<<jenkins.adoc#build_jenkins,Gradle on CI>> :: Gradle integration with popular continuous integration (CI) servers.

[[reference]]
== Reference

import gradlebuild.basics.googleApisJs

plugins {
    id("gradlebuild.internal.java")
}

description = "Collection of test fixtures for performance tests, internal use only"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

val reports by configurations.creating
val flamegraph by configurations.creating

        List<String> javaCompileJvmArgs = findProperty('javaCompileJvmArgs')?.tokenize(';') ?: []

        tasks.withType(AbstractCompile).configureEach {
            options.fork = true
            options.incremental = true
            options.forkOptions.memoryInitialSize = compilerMemory
            options.forkOptions.memoryMaximumSize = compilerMemory
            options.forkOptions.jvmArgs.addAll(javaCompileJvmArgs)
        }

        given:
        runner.tasksToRun = ["assemble"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    def "incremental compile"() {
        given:
        runner.tasksToRun = ["assemble"]

*/

package config

import (
	"context"
	"sync"

	"k8s.io/apimachinery/pkg/util/wait"
)

type merger interface {
	// Invoked when a change from a source is received.  May also function as an incremental
	// merger if you wish to consume changes incrementally.  Must be reentrant when more than
	// one source is defined.
	Merge(source string, update interface{}) error
}

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

package org.gradle.api.internal.tasks.compile.incremental.compilerapi.deps;

import com.google.common.collect.ImmutableSet;
import org.gradle.internal.serialize.HierarchicalNameSerializer;
import org.gradle.internal.serialize.AbstractSerializer;

     * crawlers to retrieve only a subset of the Sitemaps in the index i.e. a
     * crawler may only retrieve Sitemaps that were modified since a certain
     * date. This incremental Sitemap fetching mechanism allows for the rapid
     * discovery of new URLs on very large sites.
     */
    private String lastmod;

    /*
     * (non-Javadoc)
     *

3. You learned about dependency management in <<part3_gradle_dep_man#part3_begin,part 3>>.
4. You applied a plugin to your app in <<part4_gradle_plugins#part4_begin,part 4>>.
5. You learned about incremental builds in <<part5_gradle_inc_builds#part5_begin,part 5>>.
6. You turned on the local cache in <<part6_gradle_caching#part6_begin,part 6>>.

== Step 1. Gradle References
To work with Gradle, the following references are useful: