const string& full_type() const { return full_type_; }
  const string& base_type() const { return base_type_; }
  const AttrValue& default_value() const { return default_value_; }
  const bool is_list() const { return is_list_; }

 private:
  explicit AttrSpec(const OpDef::AttrDef& attr_def);

  string name_;
  string description_;
  string full_type_;
  string base_type_;
  AttrValue default_value_;

  // can be used to set a FullTypeDef based on dtype in a derived class if
  // appropriate.
  virtual tensorflow::FullTypeDef FullType() const = 0;

  // The default debug string includes a shape, dtype and FullType.
  // Implementations are free to override it with something more informative.
  virtual std::string DebugString() const;

  AbstractTensorHandleKind getKind() const { return kind_; }

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tWhm0JFMPJ5I"
      },
      "source": [
        "Copyright 2024 Google LLC.\n",
        "\n",
        "Licensed under the Apache License, Version 2.0 (the \"License\");"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RJcqTAlfPQjk"
      },
      "source": [

    return absl::StrCat("SetAttr", toUpperCamel(attr_.full_type()));
  } else {
    return absl::StrCat("SetAttr", toUpperCamel(attr_.base_type()), "List");
  }
}

std::vector<string> AttrView::SetterArgs() const {
  if (attr_.full_type() == "string") {
    return {AttrNameString(), VariableName(), VariableStrLen()};
  } else if (attr_.full_type() == "list(string)") {

  name_ = attr_def.name();
  description_ = attr_def.description();
  full_type_ = attr_def.type();
  default_value_ = attr_def.default_value();
  if (str_util::StartsWith(full_type_, "list(")) {
    is_list_ = true;
    // strip surrounding "list(%s)"
    base_type_ = full_type_.substr(5, full_type_.length() - 6);
  } else {
    is_list_ = false;
    base_type_ = full_type_;
  }
}

}  // namespace generator

 */

package org.gradle.declarative.dsl.schema

import org.gradle.tooling.ToolingModelContract
import java.io.Serializable


@ToolingModelContract(subTypes = [
    DataType.NullType::class,
    DataType.UnitType::class,
    DataType.ConstantType::class,
    DataType.IntDataType::class,
    DataType.LongDataType::class,
    DataType.StringDataType::class,
    DataType.BooleanDataType::class,

    is DataType.IntDataType -> right is DataType.IntDataType
    is DataType.LongDataType -> right is DataType.LongDataType
    is DataType.StringDataType -> right is DataType.StringDataType
    is DataType.NullType -> right is DataType.NullType
    is DataType.UnitType -> right is DataType.UnitType
}


internal
fun TypeRefContext.getDataType(objectOrigin: ObjectOrigin): DataType = when (objectOrigin) {

import javax.lang.model.type.ErrorType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.NoType;
import javax.lang.model.type.NullType;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
import javax.lang.model.type.UnionType;

#include "tensorflow/c/python_api.h"

#include <string>

#include "tensorflow/c/c_api_internal.h"
#include "tensorflow/core/framework/cpp_shape_inference.pb.h"
#include "tensorflow/core/framework/full_type.pb.h"

namespace tensorflow {

// Hack to export the tensorflow::RecordMutation symbol for windows.
// Do not delete. Do not use.
void ExportRecordMutation(  // NOLINT: Intentionally unused function.

        override fun toString(): String = "Boolean"
        private
        fun readResolve(): Any = DefaultBooleanDataType
    }

    @Serializable
    @SerialName("null")
    data object DefaultNullType : DataType.NullType {
        override fun toString(): String = "Null"
        private
        fun readResolve(): Any = DefaultNullType
    }

    @Serializable
    @SerialName("unit")