import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.api.internal.tasks.TaskDependencyResolveContext;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.internal.deprecation.DeprecationLogger;

import java.io.File;
import java.util.Collections;
import java.util.List;
import java.util.Set;

// statistics via calibration.
//
// This preset is equivalent to the following `QuantizationSpecs`:
//
// ```
// specs {matcher {function_name {regex: ".*"}} method {static_range_ptq {}}}
// specs {
//   matcher {function_name {regex: "composite_conv.*"}}
//   method {static_range_ptq {
//     input_quantized_types {
//       key: 1

package(
    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
    default_visibility = ["//visibility:private"],
    licenses = ["notice"],
)

cc_library(
    name = "views",
    srcs = glob(
        ["*.cc"],
        exclude = ["*_test.cc"],
    ),
    hdrs = glob(["*.h"]),
    visibility = ["//tensorflow/c/experimental/ops/gen/cpp/renderers:__pkg__"],
    deps = [

				_ = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPCNT, 5)

				// Wait time after successful probe in seconds.
				// ~ cat /proc/sys/net/ipv4/tcp_keepalive_intvl (defaults to 75 secs, we reduce it to 15 secs)
				_ = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPINTVL, 15)
			}

			// Set tcp user timeout in addition to the keep-alive - tcp-keepalive is not enough to close a socket

  absl::Span<std::string> exported_names(exported_names_in_vector);

  if (exported_names.empty()) {
    return errors::Unimplemented("Need at least one exported name.");
  }

  tensorflow::GraphImportConfig specs;
  specs.upgrade_legacy = true;

  std::vector<std::string> custom_opdefs(toco_flags.custom_opdefs().begin(),
                                         toco_flags.custom_opdefs().end());

    // second operand, which is weight.
    const QuantizedType& quantized_type = input_quantized_types.at(1);
    if (const auto& specs = quantized_type.dimension_specs();
        specs.has_dimension()) {
      return specs.dimension() >= 0 && specs.dimension() < rank;
    }
    return true;
  }

  static bool IsPerTensor(const WeightOnlyPtq& weight_only_ptq) {

import org.gradle.api.problems.internal.GradleCoreProblemGroup;
import org.gradle.api.problems.internal.InternalProblemSpec;
import org.gradle.api.problems.internal.InternalProblems;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.configuration.project.BuiltInCommand;
import org.gradle.execution.ProjectSelectionException;
import org.gradle.execution.TaskSelection;
import org.gradle.execution.TaskSelectionException;

    }

    static List<Spec> specsWithoutSystemPropertyAccess() {
        specs().findAll { spec -> spec.systemPropertyAccess == SystemPropertyAccess.NO_ACCESS }
    }

    static List<Spec> specsWithSystemPropertyAccess() {
        specs().findAll { spec -> spec.systemPropertyAccess != SystemPropertyAccess.NO_ACCESS }
    }

    static List<Spec> specs() {
        [
            definitions(),
            SystemPropertyAccess.values()

	"stack",   // stack ID
	"value",   // uint64
	"task",    // trace.TaskID
}

// Names is a helper that produces a mapping of event names to event types.
func Names(specs []Spec) map[string]Type {
	nameToType := make(map[string]Type)
	for i, spec := range specs {
		nameToType[spec.Name] = Type(byte(i))
	}
	return nameToType
}

// Experiment is an experiment ID that events may be associated with.
type Experiment uint

errorprone {
    disabledChecks.addAll(
        "InlineMeSuggester", // 1 occurrences
    )
}

dependencies {
    implementation(project(":base-services-groovy")) // for 'Specs'
    implementation(project(":core-api"))
    implementation(project(":dependency-management"))
    implementation(project(":launcher"))
    implementation(project(":resources"))
    implementation(project(":testing-base"))