* limitations under the License.
 */

package org.gradle.internal.cc.impl.cacheentry

import org.gradle.internal.hash.HashCode
import org.gradle.util.Path


internal
data class ModelKey(
    val identityPath: Path?,
    val modelName: String,
    val parameterHash: HashCode?

            val addressSerializer = BlockAddressSerializer()
            val intermediateModels = mutableMapOf<ModelKey, BlockAddress>()
            readCollection {
                val modelKey = readModelKey()
                val address = addressSerializer.read(this)
                intermediateModels[modelKey] = address
            }
            val metadata = mutableMapOf<Path, BlockAddress>()
            readCollection {

    private val cacheFingerprintController: ConfigurationCacheFingerprintController
) : ProjectStateStore<ModelKey, IntermediateModel>(store, StateType.IntermediateModels, "intermediate model", calculatedValueContainerFactory) {
    override fun projectPathForKey(key: ModelKey) = key.identityPath

    override fun write(encoder: Encoder, value: IntermediateModel) {

import java.io.File


/**
 * Data stored in the "entry details" file. Provides some metadata about the cache entry.
 */
internal
class EntryDetails(
    val rootDirs: List<File>,
    val intermediateModels: Map<ModelKey, BlockAddress>,
    val projectMetadata: Map<Path, BlockAddress>,
    val sideEffects: List<BlockAddress>,

  std::string expected_value = "test_data";

  // Load input model
  auto input_fbm = tflite::FlatBufferModel::BuildFromFile(
      "tensorflow/lite/testdata/sparse_tensor.bin");
  tflite::ModelT input_model;
  input_fbm->GetModel()->UnPackTo(&input_model);

  // Populate input metadata
  auto model_metadata_buffer = std::make_unique<tflite::BufferT>();
  model_metadata_buffer->data =

    Collection<? extends DependencyGraphEdge> getIncomingEdges();

    Collection<? extends DependencyGraphEdge> getOutgoingEdges();

    /**
     * The outgoing file dependencies of this node. Should be modelled edges to another node, but are treated separately for now.
     */
    Set<? extends LocalFileDependencyMetadata> getOutgoingFileEdges();

    VariantGraphResolveMetadata getMetadata();

    boolean isSelected();

package unix_test

import (
	"internal/goarch"
	"internal/syscall/unix"
	"runtime"
	"strings"
	"testing"
	"unsafe"
)

// TestSiginfoChildLayout validates SiginfoChild layout. Modelled after
// static assertions in linux kernel's arch/*/kernel/signal*.c.
func TestSiginfoChildLayout(t *testing.T) {
	var si unix.SiginfoChild

	const host64bit = goarch.PtrSize == 8

// already had some state. Instead, the returned object from here can be used to
// overwrite existing model.
ModelT UnPackFlatBufferModel(const Model& flatbuffer_model) {
  ModelT model;
  flatbuffer_model.UnPackTo(&model);
  return model;
}

TfLiteStatus QuantizeModel(
    ModelT* model, const TensorType& input_type, const TensorType& output_type,

#include "tensorflow/compiler/mlir/lite/schema/schema_generated.h"

namespace mlir {
namespace lite {

// Sparsify the `input_model` and write the result to a flatbuffer `builder`.
absl::Status SparsifyModel(const tflite::ModelT& input_model,
                           flatbuffers::FlatBufferBuilder* builder);
}  // namespace lite
}  // namespace mlir

namespace mlir {
namespace {
std::optional<std::unique_ptr<tflite::ModelT>> InjectStatsToFullyConnected(
    llvm::StringRef buffer) {
  auto model_ptr = tflite::FlatBufferModel::VerifyAndBuildFromBuffer(
      buffer.data(), buffer.size());
  if (nullptr == model_ptr) {
    return std::nullopt;
  }
  std::unique_ptr<tflite::ModelT> model(model_ptr->GetModel()->UnPack());

  // FB-LABEL:     name: "arg0",