string AttrView::DefaultValue() const {
  const AttrValue &attr_value = attr_.default_value();
  switch (attr_value.value_case()) {
    case AttrValue::VALUE_NOT_SET:
      return "";
    case AttrValue::kType:
      return DataType_Name(attr_value.type());
    case AttrValue::kS:
      return "\"" + attr_value.s() + "\"";
    case AttrValue::kI:
      return std::to_string(attr_value.i());
    case AttrValue::kF:

}

string PrintAttrValue(const string& op, const AttrValue& attr_value) {
  switch (attr_value.value_case()) {
    case AttrValue::kS:
      return PrintString(attr_value.s());
    case AttrValue::kI:
      return strings::StrCat(attr_value.i());
    case AttrValue::kF: {
      const float f = attr_value.f();
      if (std::isinf(f)) {
        return strings::StrCat(f < 0.0f ? "-" : "+",

}

std::pair<string, AttrValue> impl::AttrLiteralHelper(
    const std::pair<string, bool>& bool_attr) {
  AttrValue attr_value;
  attr_value.set_b(bool_attr.second);
  return {bool_attr.first, attr_value};
}

std::pair<string, AttrValue> impl::AttrLiteralHelper(
    const std::pair<string, absl::Span<const int>>& int_list_attr) {
  AttrValue attr_value;
  AttrValue::ListValue* list = attr_value.mutable_list();

  for (const auto& name_attr_pair : n.attrs()) {
    const AttrValue& attr_value = name_attr_pair.second;
    if (attr_value.value_case() == AttrValue::kFunc) {
      result.push_back(attr_value.func());
    } else if (attr_value.value_case() == AttrValue::kList) {
      result.insert(result.end(), attr_value.list().func().begin(),
                    attr_value.list().func().end());
    }
  }

  return result;
}

      *list->add_tensor() = tensor;
    } else if (auto attr = mlir::dyn_cast<mlir::FlatSymbolRefAttr>(a)) {
      AttrValue attr_val;
      TF_RETURN_IF_ERROR(ConvertAttribute(attr, &attr_val));
      *list->add_func() = attr_val.func();
    } else if (auto attr = mlir::dyn_cast<mlir::TypeAttr>(a)) {
      AttrValue attr_val;
      // For type attributes, we only propagate the element type.
      mlir::Type elt_type = attr.getValue();

  }
  return ret;
}

string PrintTensor(const TensorProto& tensor_proto);

string PrintTensorProto(const TensorProto& proto);

string PrintAttrValue(StringPiece, const AttrValue& attr_value);

bool IsEmptyList(const AttrValue::ListValue& list);

string ToCamelCase(StringPiece str);

string SeparateNamespaces(StringPiece str);

// Returns a <string, bool> pair. The string is the C++ type name to be used for

    for (const auto& name_and_value : node_def.attr()) {
      const std::string& attr_name = name_and_value.first;
      const tensorflow::AttrValue& attr_value = name_and_value.second;
      absl::StatusOr<Attribute> mlir_attr =
          tensorflow::ConvertAttributeValue(attr_value, &builder);
      if (!mlir_attr.ok()) {
        return emitError(loc, mlir_attr.status().message());
      }

absl::StatusOr<mlir::Attribute> ConvertNonFuncAttributeValue(
    const AttrValue& value, mlir::Builder* builder);

// Converts all kinds of AttrValue proto into an MLIR attribute.
absl::StatusOr<mlir::Attribute> ConvertAttributeValue(const AttrValue& value,
                                                      mlir::Builder* builder);

}  // namespace tensorflow

          device.has_job && device.job == jobType) {
        for (const auto& attr : node->attrs()) {
          auto attr_key = attr.first;
          auto attr_value = attr.second;
          if (attr_key == attrKey &&
              attr_value.value_case() == AttrValue::kType &&
              attr_value.type() == DT_RESOURCE) {
            return true;
            break;
          }
        }
      }
    }
  }
  return false;

  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_;
  bool is_list_;
};

}  // namespace generator