import org.gradle.api.Task;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Resolves dependencies to {@link TaskNode} objects. Uses the same logic as {@link #TASK_AS_TASK}.
 */
@ServiceScope(Scope.Build.class)
public class TaskNodeDependencyResolver implements DependencyResolver {
    private final TaskNodeFactory taskNodeFactory;

        (valueSource as? Describable)?.let {
            it.displayName + " has changed"
        } ?: "a build logic input of type '${unpackType(valueSource).simpleName}' has changed"

    private
    fun buildLogicInputFailed(obtainedValue: ObtainedValue, failure: Throwable): InvalidationReason =
        "a build logic input of type '${obtainedValue.valueSourceType.simpleName}' failed when storing the entry with $failure"

    private

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

package org.gradle.api.internal.file;


/**
 * Encapsulates the logic for serializing and deserializing a file collection to and from the configuration cache.
 */
public interface FileCollectionExecutionTimeValue {

    "meshConfig.defaultConfig.tracing.stackdriver.maxNumberOfMessageEvents" "Istio supported tracers"
}}
{{- range $dep, $replace := $deps }}
{{- /* Complex logic to turn the string above into a null-safe traversal like ((.Values.global).certificates */}}
{{- $res := tpl (print "{{" (repeat (split "." $dep | len) "(")  ".Values." (replace "." ")." $dep) ")}}") $}}
{{- if not (eq $res "")}}

However, there is also a bit of additional logic. Gateway types have extensive status reporting. Unlike Ingress, this is status reporting is done inline in the main controller, allowing status generation to be done directly in the logic processing the resources.

Additionally, Gateway involves two components writing to the cluster:

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

/**
 * A package that contains utils for transforms for build logic classpath.
 */
@org.gradle.api.NonNullApi

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

/**
 * Support for executing contrived Gradle builds for the purpose of testing build logic.
 *
 * @see org.gradle.testkit.runner.GradleRunner
 */

 * limitations under the License.
 */

/**
 * Configuration input tracking implementation.
 * <p>
 * The build configuration may be influenced by various "environmental" inputs.
 * For example, build logic may read files or access environment variables.
 * Knowing these inputs is important for configuration caching to understand if the cache has to be invalidated when the value of the system property changes.

    interface BuildResult {
        @Nullable
        Throwable getFailure();
    }

    interface BuildScanResult {

    }

    interface Listener {
        /**
         * Called after all user build logic has completed and the build outcome reported to the logging system. Also called prior to shutting down the build(-tree) scope services
         */
        BuildScanResult execute(BuildResult buildResult);
    }

	dnsProto "istio.io/istio/pkg/dns/proto"
	dnsServer "istio.io/istio/pkg/dns/server"
)

// BuildNameTable produces a table of hostnames and their associated IPs that can then
// be used by the agent to resolve DNS. This logic is always active. However, local DNS resolution
// will only be effective if DNS capture is enabled in the proxy
func (configgen *ConfigGeneratorImpl) BuildNameTable(node *model.Proxy, push *model.PushContext) *dnsProto.NameTable {